redux-event-emitter
Version:
Redux Event Emitter Middleware
264 lines (206 loc) • 8.31 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define("redux-event-emitter", [], factory);
else if(typeof exports === 'object')
exports["redux-event-emitter"] = factory();
else
root["redux-event-emitter"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.reduxEventEmitter = undefined;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
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 _tinyEmitter = __webpack_require__(1);
var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var ReduxEventEmitter = function () {
function ReduxEventEmitter() {
_classCallCheck(this, ReduxEventEmitter);
this.emitter = new _tinyEmitter2.default();
}
_createClass(ReduxEventEmitter, [{
key: 'createEvents',
value: function createEvents() {
var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if ((typeof events === 'undefined' ? 'undefined' : _typeof(events)) !== 'object') {
throw new TypeError('createEvents expects events object as its first parameter, you passed type "' + (typeof events === 'undefined' ? 'undefined' : _typeof(events)) + '"');
}
Object.keys(events).forEach(function (key) {
if (typeof events[key] !== 'function') {
throw new TypeError('Each key in createEvents\'s events object must be a dispatch-able function, key "' + key + '" is of type "' + _typeof(events[key]) + '"');
}
});
var self = this;
return function (_ref) {
var dispatch = _ref.dispatch;
Object.keys(events).forEach(function (key) {
self.emitter.on(key, function () {
dispatch(events[key].apply(events, arguments));
});
});
return function (next) {
return function (action) {
if (action.type.startsWith('@@emitter')) {
var _self$emitter;
(_self$emitter = self.emitter).emit.apply(_self$emitter, [action.channel].concat(_toConsumableArray(action.args || [])));
}
return next(action);
};
};
};
}
}, {
key: 'once',
value: function once() {
var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if ((typeof events === 'undefined' ? 'undefined' : _typeof(events)) !== 'object') {
throw new TypeError('createEvents expects events object as its first parameter, you passed type \'' + (typeof events === 'undefined' ? 'undefined' : _typeof(events)) + '"');
}
Object.keys(events).forEach(function (key) {
if (typeof events[key] !== 'function') {
throw new TypeError('Each key in createEvents\'s events object must be a dispatch-able function, key "' + key + '" is of type "' + _typeof(events[key]) + '"');
}
});
var self = this;
return function (_ref2) {
var dispatch = _ref2.dispatch;
Object.keys(events).forEach(function (key) {
self.emitter.once(key, function () {
dispatch(events[key].apply(events, arguments));
});
});
return function (next) {
return function (action) {
return next(action);
};
};
};
}
// ------------------------------------
// emitter Proxies
// ------------------------------------
}, {
key: 'emit',
value: function emit(channel) {
return {
type: '@@emitter',
channel: channel,
args: Array.prototype.slice.call(arguments, 1)
};
}
}, {
key: 'off',
value: function off(channel) {
return this.emitter.off(channel);
}
}, {
key: 'on',
value: function on() {
var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return this.createEvents(events);
}
}]);
return ReduxEventEmitter;
}();
var reduxEventEmitter = exports.reduxEventEmitter = new ReduxEventEmitter();
/***/ },
/* 1 */
/***/ function(module, exports) {
function E () {
// Keep this empty so it's easier to inherit from
// (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
}
E.prototype = {
on: function (name, callback, ctx) {
var e = this.e || (this.e = {});
(e[name] || (e[name] = [])).push({
fn: callback,
ctx: ctx
});
return this;
},
once: function (name, callback, ctx) {
var self = this;
function listener () {
self.off(name, listener);
callback.apply(ctx, arguments);
};
listener._ = callback
return this.on(name, listener, ctx);
},
emit: function (name) {
var data = [].slice.call(arguments, 1);
var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
var i = 0;
var len = evtArr.length;
for (i; i < len; i++) {
evtArr[i].fn.apply(evtArr[i].ctx, data);
}
return this;
},
off: function (name, callback) {
var e = this.e || (this.e = {});
var evts = e[name];
var liveEvents = [];
if (evts && callback) {
for (var i = 0, len = evts.length; i < len; i++) {
if (evts[i].fn !== callback && evts[i].fn._ !== callback)
liveEvents.push(evts[i]);
}
}
// Remove event from queue to prevent memory leak
// Suggested by https://github.com/lazd
// Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
(liveEvents.length)
? e[name] = liveEvents
: delete e[name];
return this;
}
};
module.exports = E;
module.exports.TinyEmitter = E;
/***/ }
/******/ ])
});
;