rel-events
Advanced tools
Comparing version 0.2.3 to 0.3.0
"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; |
"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.'); |
69
index.js
@@ -1,14 +0,57 @@ | ||
import eventsMiddleware from 'react-redux-api-tools/lib/middleware'; | ||
import fetchFromApi from 'react-redux-api-tools/lib/api'; | ||
import { Event, HTTPEvent } from './dist/events'; | ||
import { getCurrentStateFromEvent, dispatchEvent, combineEventReducers } from './dist/helpers'; | ||
"use strict"; | ||
export { | ||
eventsMiddleware, | ||
fetchFromApi, | ||
Event, | ||
HTTPEvent, | ||
combineEventReducers, | ||
dispatchEvent, | ||
getCurrentStateFromEvent, | ||
}; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
Object.defineProperty(exports, "eventsMiddleware", { | ||
enumerable: true, | ||
get: function get() { | ||
return _middleware.default; | ||
} | ||
}); | ||
Object.defineProperty(exports, "fetchFromApi", { | ||
enumerable: true, | ||
get: function get() { | ||
return _api.default; | ||
} | ||
}); | ||
Object.defineProperty(exports, "Event", { | ||
enumerable: true, | ||
get: function get() { | ||
return _events.Event; | ||
} | ||
}); | ||
Object.defineProperty(exports, "HTTPEvent", { | ||
enumerable: true, | ||
get: function get() { | ||
return _events.HTTPEvent; | ||
} | ||
}); | ||
Object.defineProperty(exports, "getCurrentStateFromEvent", { | ||
enumerable: true, | ||
get: function get() { | ||
return _helpers.getCurrentStateFromEvent; | ||
} | ||
}); | ||
Object.defineProperty(exports, "dispatchEvent", { | ||
enumerable: true, | ||
get: function get() { | ||
return _helpers.dispatchEvent; | ||
} | ||
}); | ||
Object.defineProperty(exports, "combineEventReducers", { | ||
enumerable: true, | ||
get: function get() { | ||
return _helpers.combineEventReducers; | ||
} | ||
}); | ||
var _middleware = _interopRequireDefault(require("react-redux-api-tools/lib/middleware")); | ||
var _api = _interopRequireDefault(require("react-redux-api-tools/lib/api")); | ||
var _events = require("./dist/events"); | ||
var _helpers = require("./dist/helpers"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
{ | ||
"name": "rel-events", | ||
"version": "0.2.3", | ||
"version": "0.3.0", | ||
"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", |
Sorry, the diff of this file is not supported yet
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
165141
1127