fixed bugs

Author: jmenestr

.gitignore

@@ -1,2 +1 @@
 node_modules/
-lib/

lib/actions.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.destroyAllAlerts = exports.dismissAllAlerts = exports.destroyAlert = exports.dismissAlert = exports.createAlert = exports.initializeAlert = undefined;
+
+var _constants = require('./constants');
+
+var alertConstants = _interopRequireWildcard(_constants);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var initializeAlert = exports.initializeAlert = function initializeAlert(alertName) {
+  return { type: alertConstants.INITIALIZE_ALERT, alertName: alertName };
+};
+
+var createAlert = exports.createAlert = function createAlert(alertName) {
+  return { type: alertConstants.CREATE_ALERT, alertName: alertName };
+};
+
+var dismissAlert = exports.dismissAlert = function dismissAlert(alertName) {
+  return { type: alertConstants.DISMISS_ALERT, alertName: alertName };
+};
+
+var destroyAlert = exports.destroyAlert = function destroyAlert(alertName) {
+  return { type: alertConstants.DESTROY_ALERT, alertName: alertName };
+};
+
+var dismissAllAlerts = exports.dismissAllAlerts = function dismissAllAlerts() {
+  return { type: alertConstants.DISMISS_ALL_ALERTS };
+};
+
+var destroyAllAlerts = exports.destroyAllAlerts = function destroyAllAlerts() {
+  return { type: alertConstants.DESTROY_ALL_ALERTS };
+};

lib/alertContainer.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _reactRedux = require('react-redux');
+
+var _redux = require('redux');
+
+var _actions = require('./actions');
+
+var alertActions = _interopRequireWildcard(_actions);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var createAlert = function createAlert(config) {
+  return function (WrappedComponent) {
+    var alertName = config.alertName;
+
+    var AlertContainer = function (_Component) {
+      _inherits(AlertContainer, _Component);
+
+      function AlertContainer() {
+        _classCallCheck(this, AlertContainer);
+
+        return _possibleConstructorReturn(this, Object.getPrototypeOf(AlertContainer).apply(this, arguments));
+      }
+
+      _createClass(AlertContainer, [{
+        key: 'componentDidMount',
+        value: function componentDidMount() {
+          this.props.actions.initializeAlert(alertName);
+        }
+      }, {
+        key: 'componentWillUnmount',
+        value: function componentWillUnmount() {
+          this.props.actions.destoryAlert(alertName);
+        }
+      }, {
+        key: 'render',
+        value: function render() {
+          if (!this.props.isVisible) return false;
+          return _react2.default.createElement(WrappedComponent, null);
+        }
+      }]);
+
+      return AlertContainer;
+    }(_react.Component);
+
+    function mapStateToProps(state) {
+      return { isVisible: state.alerts ? state.alerts[alertName] : false };
+    };
+
+    function mapDispatchToProps(dispatch) {
+      return { actions: (0, _redux.bindActionCreators)(alertActions, dispatch) };
+    };
+    return (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(AlertContainer);
+  };
+};
+
+exports.default = createAlert;

lib/constants.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var INITIALIZE_ALERT = exports.INITIALIZE_ALERT = 'redux-alerts/INITIALIZE_ALERT';
+var CREATE_ALERT = exports.CREATE_ALERT = 'redux-alerts/CREATE_ALERT';
+var DISMISS_ALERT = exports.DISMISS_ALERT = 'redux-alerts/DISMISS_ALERT';
+var DISMISS_ALL_ALERTS = exports.DISMISS_ALL_ALERTS = 'redux-alerts/DISMISS_ALL_ALERTS';
+var DESTROY_ALL_ALERTS = exports.DESTROY_ALL_ALERTS = 'redux-alerts/DESTROY_ALL_ALERTS';
+var DESTROY_ALERT = exports.DESTROY_ALERT = 'redux-alerts/DESTROY_ALERT';

lib/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _actions = require('./actions');
+
+var _actions2 = _interopRequireDefault(_actions);
+
+var _reducer = require('./reducer');
+
+var _reducer2 = _interopRequireDefault(_reducer);
+
+var _constants = require('./constants');
+
+var _constants2 = _interopRequireDefault(_constants);
+
+var _alertContainer = require('./alertContainer');
+
+var _alertContainer2 = _interopRequireDefault(_alertContainer);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
+  actions: _actions2.default,
+  alertReducer: _reducer2.default,
+  constants: _constants2.default,
+  createAlert: _alertContainer2.default
+};

lib/reducer.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _behaviors;
+
+var _constants = require('./constants');
+
+var alertTypes = _interopRequireWildcard(_constants);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var behaviors = (_behaviors = {}, _defineProperty(_behaviors, alertTypes.CREATE_ALERT, function (state, action) {
+  return true;
+}), _defineProperty(_behaviors, alertTypes.DISMISS_ALERT, function (state, action) {
+  return false;
+}), _behaviors);
+
+var initialAlertState = false;
+
+var reducer = function reducer(state, action) {
+  var behavior = behaviors[action.type];
+  return behavior ? behavior(state, action) : state;
+};
+
+var alertReducer = function alertReducer() {
+  var state = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+  var action = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+  var type = action.type;
+  var alertName = action.alertName;
+
+  if (state === undefined) return state;
+  if (type === alertTypes.INITIALIZE_ALERT) {
+    return _extends({}, state, _defineProperty({}, alertName, false));
+  }
+  if (type === alertTypes.DISMISS_ALL_ALERTS) {
+    return Object.keys(state).reduce(function (acc, alert) {
+      var prev = Object.assign({}, acc, _defineProperty({}, alert, initialAlertState));
+      return prev;
+    }, {});
+  }
+
+  if (state[alertName] === undefined) return state;
+  if (type === alertTypes.DESTROY_ALERT) {
+    return Object.keys(state).reduce(function (acc, alert) {
+      var prev = alert === alertName ? acc : _extends({}, acc, _defineProperty({}, alert, state[alert]));
+      return prev;
+    }, {});
+  }
+  return Object.assign({}, state, _defineProperty({}, alertName, reducer(state[alertName], action)));
+};
+exports.default = alertReducer;

npm-debug.log

@@ -1,6 +1,6 @@
 {
   "name": "react-redux-alerts",
-  "version": "1.3.1",
+  "version": "1.3.11",
   "description": "A lightweight library for creating keyed alerts in a Redux app",
   "main": "./lib/index.js",
   "scripts": {

package.json

@@ -22,9 +22,15 @@ const createAlert = config => WrappedComponent => {
     }
   }
 
-  const mapStateToProps = state => { isVisible: state.alerts[alertName] };
-  const mapDispatchToProps = dispatch => { actions: bindActionCreators(alertActions, dispatch) };
+  function mapStateToProps (state) {
+    return { isVisible: state.alerts ? state.alerts[alertName] : false };
+  };
+
+  function mapDispatchToProps (dispatch) {
+    return { actions: bindActionCreators(alertActions, dispatch) };
+  };
   return connect(mapStateToProps, mapDispatchToProps)(AlertContainer);
+  
 };
 
 export default createAlert;

src/alertContainer.js

@@ -1,7 +1,7 @@
 import actions from './actions';
 import alertReducer from './reducer';
 import constants from './constants';
-import createAlert from '/alertContainer';
+import createAlert from './alertContainer';
 
 export default {
   actions,

src/index.js

@@ -19,6 +19,7 @@ const reducer = (state, action) => {
 
 const alertReducer = (state = {}, action = {}) => {
   const {type, alertName } = action;
+  if (state === undefined) return state;
   if (type === alertTypes.INITIALIZE_ALERT) {
       return {
         ...state,
@@ -32,6 +33,7 @@ const alertReducer = (state = {}, action = {}) => {
       return prev;
     }, {});
   }
+
   if (state[alertName] === undefined) return state;
   if (type === alertTypes.DESTROY_ALERT) {
     return Object.keys(state).reduce((acc, alert) => {