rel-events - npm Package Compare versions

Comparing version 0.2.2 to 0.2.3-ie11

dist/events.js

 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
@@ -8,51 +10,80 @@ value: true
 
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
 var _reactRedux = require("react-redux");
 
-class Event {
-  constructor({
-    name: _name,
-    manager,
-    useDataFrom,
-    listenTo: _listenTo = []
-  } = {}) {
-    this.toRedux = data => ({
-      type: this.reducerName,
-      shouldDispatch: this.manager.shouldDispatch || (() => true),
-      ...data
-    });
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-    this.createReducers = () => {
-      const reducers = {};
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-      if (this.useDataFrom) {
-        reducers[this.useDataFrom] = this._createReducersTo();
-      } else {
-        reducers[this.name] = this._createReducersTo();
-      }
+var Event = function Event() {
+  var _this = this;
 
-      return reducers;
-    };
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _name = _ref.name,
+      manager = _ref.manager,
+      useDataFrom = _ref.useDataFrom,
+      _ref$listenTo = _ref.listenTo,
+      _listenTo = _ref$listenTo === void 0 ? [] : _ref$listenTo;
 
-    this.register = ({
-      Component,
-      props = []
-    }) => {
-      if (!Component) {
-        throw new Error('You must pass a Component inside the Component key when registering it to an Event.');
+  (0, _classCallCheck2.default)(this, Event);
+
+  this.toRedux = function (data) {
+    return _objectSpread({
+      type: _this.reducerName,
+      shouldDispatch: _this.manager.shouldDispatch || function () {
+        return true;
       }
+    }, data);
+  };
 
-      return (0, _reactRedux.connect)(this._bindDataToProps(props), this._bindDispatchToProps)(Component);
-    };
+  this.createReducers = function () {
+    var reducers = {};
 
-    this._createReducersTo = () => (state = this.manager.initialState, action) => {
-      if (action.type === this.reducerName) {
-        const newState = this.manager.onDispatch(state, action);
+    if (_this.useDataFrom) {
+      reducers[_this.useDataFrom] = _this._createReducersTo();
+    } else {
+      reducers[_this.name] = _this._createReducersTo();
+    }
 
-        if (this.manager.afterDispatch) {
-          setTimeout(() => this.manager.afterDispatch(state, newState), 0);
+    return reducers;
+  };
+
+  this.register = function (_ref2) {
+    var Component = _ref2.Component,
+        _ref2$props = _ref2.props,
+        props = _ref2$props === void 0 ? [] : _ref2$props;
+
+    if (!Component) {
+      throw new Error('You must pass a Component inside the Component key when registering it to an Event.');
+    }
+
+    return (0, _reactRedux.connect)(_this._bindDataToProps(props), _this._bindDispatchToProps)(Component);
+  };
+
+  this._createReducersTo = function () {
+    return function () {
+      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.manager.initialState;
+      var action = arguments.length > 1 ? arguments[1] : undefined;
+
+      if (action.type === _this.reducerName) {
+        var newState = _this.manager.onDispatch(state, action);
+
+        if (_this.manager.afterDispatch) {
+          setTimeout(function () {
+            return _this.manager.afterDispatch(state, newState);
+          }, 0);
         }
 
-        this.__UNSAFE_state = newState;
+        _this.__UNSAFE_state = newState;
 
-        this._chainEvents(action);
+        _this._chainEvents(action);
 
@@ -64,147 +95,172 @@ return newState;
     };
+  };
 
-    this._chainEvents = action => {
-      const {
-        listenTo,
-        toRedux
-      } = this;
+  this._chainEvents = function (action) {
+    var listenTo = _this.listenTo,
+        toRedux = _this.toRedux;
 
-      if (listenTo.length) {
-        listenTo.map(({
-          event,
-          triggerOn
-        }) => {
-          event = event();
-          const reducer = event.reducerName ? event.reducerName : event.reducers[triggerOn];
+    if (listenTo.length) {
+      listenTo.map(function (_ref3) {
+        var event = _ref3.event,
+            triggerOn = _ref3.triggerOn;
+        event = event();
+        var reducer = event.reducerName ? event.reducerName : event.reducers[triggerOn];
 
-          if (action.type === reducer) {
-            setTimeout(() => action.__UNSAFE_dispatch(toRedux(event.__UNSAFE_state)));
-          }
-        });
-      }
+        if (action.type === reducer) {
+          setTimeout(function () {
+            return action.__UNSAFE_dispatch(toRedux(event.__UNSAFE_state));
+          });
+        }
+      });
+    }
+  };
+
+  this._dispatch = function (reduxDispatch) {
+    return function (dispatchData) {
+      return reduxDispatch(_this.toRedux(dispatchData));
     };
+  };
 
-    this._dispatch = reduxDispatch => dispatchData => reduxDispatch(this.toRedux(dispatchData));
+  this._bindDataToProps = function (props) {
+    if (_this.useDataFrom && props.length) {
+      throw new Error("When configuring 'useDataFrom', you will end up with an empty state. Listen to the event with the name described in the 'useDataFrom' key instead.");
+    }
 
-    this._bindDataToProps = props => {
-      if (this.useDataFrom && props.length) {
-        throw new Error(`When configuring 'useDataFrom', you will end up with an empty state. Listen to the event with the name described in the 'useDataFrom' key instead.`);
-      }
-
-      const {
-        name
-      } = this;
-      return state => {
-        const data = {};
-        data[`_event_${name}`] = this;
-        props.map(key => {
-          data[key] = state[name][key];
-          return null;
-        });
-        return data;
-      };
+    var name = _this.name;
+    return function (state) {
+      var data = {};
+      data["_event_".concat(name)] = _this;
+      props.map(function (key) {
+        data[key] = state[name][key];
+        return null;
+      });
+      return data;
     };
+  };
 
-    this._bindDispatchToProps = reduxDispatch => {
-      const actions = {};
-      actions[this.name] = this._dispatch(reduxDispatch);
-      return actions;
-    };
+  this._bindDispatchToProps = function (reduxDispatch) {
+    var actions = {};
+    actions[_this.name] = _this._dispatch(reduxDispatch);
+    return actions;
+  };
 
-    this._formatReducerName = name => name.replace(/\.?([A-Z])/g, (_x, y) => `_${y.toLowerCase()}`).replace(/^_/, '').toUpperCase();
+  this._formatReducerName = function (name) {
+    return name.replace(/\.?([A-Z])/g, function (_x, y) {
+      return "_".concat(y.toLowerCase());
+    }).replace(/^_/, '').toUpperCase();
+  };
 
-    if (arguments.length === 0) {
-      throw new Error('An Event should not be initialized without parameters.');
-    } else {
-      if (!_name) {
-        throw new Error('An Event should be initialized with an event name.');
-      }
+  if (arguments.length === 0) {
+    throw new Error('An Event should not be initialized without parameters.');
+  } else {
+    if (!_name) {
+      throw new Error('An Event should be initialized with an event name.');
+    }
 
-      if (!manager) {
-        throw new Error('An Event should be initialized with an EventManager.');
-      }
+    if (!manager) {
+      throw new Error('An Event should be initialized with an EventManager.');
+    }
 
-      if (!Array.isArray(_listenTo) || !_listenTo.every(obj => obj.hasOwnProperty('event') && obj.hasOwnProperty('triggerOn') && typeof obj.event === 'function')) {
-        throw new Error('ListenTo must be an array of { event, triggerOn } objects, and the event key should be a function that returns an Event or HTTPEvent.');
-      }
+    if (!Array.isArray(_listenTo) || !_listenTo.every(function (obj) {
+      return obj.hasOwnProperty('event') && obj.hasOwnProperty('triggerOn') && typeof obj.event === 'function';
+    })) {
+      throw new Error('ListenTo must be an array of { event, triggerOn } objects, and the event key should be a function that returns an Event or HTTPEvent.');
     }
-
-    this.name = _name;
-    this.manager = manager;
-    this.listenTo = _listenTo;
-    this.useDataFrom = useDataFrom;
-    this.__UNSAFE_state = manager.initialState;
-    this.reducerName = this._formatReducerName(this.name);
   }
 
-}
+  this.name = _name;
+  this.manager = manager;
+  this.listenTo = _listenTo;
+  this.useDataFrom = useDataFrom;
+  this.__UNSAFE_state = manager.initialState;
+  this.reducerName = this._formatReducerName(this.name);
+};
 
 exports.Event = Event;
 
-class HTTPEvent extends Event {
-  constructor({
-    name,
-    manager,
-    useDataFrom,
-    listenTo = []
-  } = {}) {
-    super({
-      name,
-      manager,
-      useDataFrom,
-      listenTo
-    });
+var HTTPEvent =
+/*#__PURE__*/
+function (_Event) {
+  (0, _inherits2.default)(HTTPEvent, _Event);
 
-    this.toRedux = dispatchData => {
-      const {
-        shouldDispatch
-      } = this.manager;
+  function HTTPEvent() {
+    var _this2;
+
+    var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        name = _ref4.name,
+        manager = _ref4.manager,
+        useDataFrom = _ref4.useDataFrom,
+        _ref4$listenTo = _ref4.listenTo,
+        listenTo = _ref4$listenTo === void 0 ? [] : _ref4$listenTo;
+
+    (0, _classCallCheck2.default)(this, HTTPEvent);
+    _this2 = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(HTTPEvent).call(this, {
+      name: name,
+      manager: manager,
+      useDataFrom: useDataFrom,
+      listenTo: listenTo
+    }));
+
+    _this2.toRedux = function (dispatchData) {
+      var shouldDispatch = _this2.manager.shouldDispatch;
       return {
-        types: this.reducers,
+        types: _this2.reducers,
         extraData: dispatchData,
-        apiCallFunction: this.manager.call(dispatchData),
-        shouldDispatch: shouldDispatch || (() => true)
+        apiCallFunction: _this2.manager.call(dispatchData),
+        shouldDispatch: shouldDispatch || function () {
+          return true;
+        }
       };
     };
 
-    this._createReducersTo = () => (state = this.manager.initialState, action) => {
-      let newState = state;
+    _this2._createReducersTo = function () {
+      return function () {
+        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this2.manager.initialState;
+        var action = arguments.length > 1 ? arguments[1] : undefined;
+        var newState = state;
 
-      if (action.type === this.reducers.request) {
-        newState = this.manager.onDispatch(state, action);
-      }
+        if (action.type === _this2.reducers.request) {
+          newState = _this2.manager.onDispatch(state, action);
+        }
 
-      if (action.type === this.reducers.success) {
-        newState = this.manager.onSuccess(state, action);
+        if (action.type === _this2.reducers.success) {
+          newState = _this2.manager.onSuccess(state, action);
 
-        if (this.manager.afterSuccess) {
-          setTimeout(() => this.manager.afterSuccess(state, newState), 0);
+          if (_this2.manager.afterSuccess) {
+            setTimeout(function () {
+              return _this2.manager.afterSuccess(state, newState);
+            }, 0);
+          }
         }
-      }
 
-      if (action.type === this.reducers.failure) {
-        newState = this.manager.onFailure(state, action);
+        if (action.type === _this2.reducers.failure) {
+          newState = _this2.manager.onFailure(state, action);
 
-        if (this.manager.afterFailure) {
-          setTimeout(() => this.manager.afterFailure(state, newState), 0);
+          if (_this2.manager.afterFailure) {
+            setTimeout(function () {
+              return _this2.manager.afterFailure(state, newState);
+            }, 0);
+          }
         }
-      }
 
-      this.__UNSAFE_state = newState;
+        _this2.__UNSAFE_state = newState;
 
-      this._chainEvents(action);
+        _this2._chainEvents(action);
 
-      return newState;
+        return newState;
+      };
     };
 
-    delete this.reducerName;
-    this.reducers = {
-      request: `${this._formatReducerName(this.name)}_REQUEST`,
-      success: `${this._formatReducerName(this.name)}_SUCCESS`,
-      failure: `${this._formatReducerName(this.name)}_FAILURE`
+    delete _this2.reducerName;
+    _this2.reducers = {
+      request: "".concat(_this2._formatReducerName(_this2.name), "_REQUEST"),
+      success: "".concat(_this2._formatReducerName(_this2.name), "_SUCCESS"),
+      failure: "".concat(_this2._formatReducerName(_this2.name), "_FAILURE")
     };
+    return _this2;
   }
 
-}
+  return HTTPEvent;
+}(Event);
 
 exports.HTTPEvent = HTTPEvent;

dist/helpers.js

 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
@@ -11,8 +13,13 @@ value: true
 
-function _combineConflictingReducers(reducers = []) {
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+function _combineConflictingReducers() {
+  var reducers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   // needed for compatibility
-  const reducersArray = reducers.map(reducer => Object.values(reducer)[0]);
-  return (state, action) => {
-    for (let i = 0; i < reducersArray.length; i++) {
-      const reducer = reducersArray[i];
+  var reducersArray = reducers.map(function (reducer) {
+    return Object.values(reducer)[0];
+  });
+  return function (state, action) {
+    for (var i = 0; i < reducersArray.length; i++) {
+      var reducer = reducersArray[i];
       state = reducer(state, action);
@@ -25,6 +32,7 @@ }
 
-function combineEventReducers(events = []) {
-  const conflictingEventsAndKeys = {};
-  const combinedReducers = {};
-  events.forEach(event => {
+function combineEventReducers() {
+  var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var conflictingEventsAndKeys = {};
+  var combinedReducers = {};
+  events.forEach(function (event) {
     if (event.useDataFrom) {
@@ -41,7 +49,9 @@ if (!conflictingEventsAndKeys[event.useDataFrom]) {
   });
-  Object.keys(conflictingEventsAndKeys).forEach(eventName => {
-    let baseEvent = events.filter(event => event.name === eventName);
+  Object.keys(conflictingEventsAndKeys).forEach(function (eventName) {
+    var baseEvent = events.filter(function (event) {
+      return event.name === eventName;
+    });
 
     if (!baseEvent.length) {
-      throw new Error(`Event with ${eventName} name not found.`);
+      throw new Error("Event with ".concat(eventName, " name not found."));
     } // eslint-disable-next-line prefer-destructuring
@@ -51,3 +61,5 @@
     baseEvent = baseEvent[0];
-    combinedReducers[eventName] = _combineConflictingReducers([baseEvent.createReducers(), ...conflictingEventsAndKeys[eventName].map(event => event.createReducers())]);
+    combinedReducers[eventName] = _combineConflictingReducers([baseEvent.createReducers()].concat((0, _toConsumableArray2.default)(conflictingEventsAndKeys[eventName].map(function (event) {
+      return event.createReducers();
+    }))));
   });
@@ -57,7 +69,7 @@ return combinedReducers;
 
-function dispatchEvent({
-  event,
-  store,
-  data
-}) {
+function dispatchEvent(_ref) {
+  var event = _ref.event,
+      store = _ref.store,
+      data = _ref.data;
+
   if (!event) {
@@ -78,6 +90,6 @@ throw new Error('You need to pass an event.');
 
-function getCurrentStateFromEvent({
-  appState,
-  event
-}) {
+function getCurrentStateFromEvent(_ref2) {
+  var appState = _ref2.appState,
+      event = _ref2.event;
+
   if (!event) {
@@ -84,0 +96,0 @@ throw new Error('You need to pass an event.');

docs/2-HTTP-Events.md

@@ -97,2 +97,25 @@ ## Creating a HTTPEvent
 
+#### Making multiple requests at the same time
+
+If you want to make multiple requests in the same call, instead of returning a single `fetchFromApi` call, you may use [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all) passing a list of `fetchFromApi` calls:
+
+```js
+// on eventManagers.js
+import { fetchFromApi } from 'rel-events';
+
+export class GetProductsHTTPEventManager {
+  // ...
+
+  call = () => {
+    return () => Promise.all([ fetchFromApi('/api/products/1'), fetchFromApi('/api/products/2'), ]);
+  }
+
+  // ...
+}
+```
+
+When all of them are successful, the `onSuccess` handler will be called, and the `event.response` will be an array of `Response` objects. If any of them fails, the `onFailure` handler will be called passing the `Error` instance (most probably a `TypeError: Failed to fetch` error).
+
+---------------
+
 Now that we're done here, maybe you should take a look at some other goodies we have on the Advanced Usage section :)

package.json

 {
   "name": "rel-events",
-  "version": "0.2.2",
+  "version": "0.2.3-ie11",
   "description": "The relevant React Events Library. Events framework based on redux to decouple our from business logic and make state management easy.",
@@ -5,0 +5,0 @@ "main": "index.js",

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

164170

increased by2.94%

Lines of code

1089

increased by4.91%

No dependency changes