(function webpackUniversalModuleDefinition(root, factory) {
|
if(typeof exports === 'object' && typeof module === 'object')
|
module.exports = factory();
|
else if(typeof define === 'function' && define.amd)
|
define("Centrifuge", [], factory);
|
else if(typeof exports === 'object')
|
exports["Centrifuge"] = factory();
|
else
|
root["Centrifuge"] = factory();
|
})(typeof self !== 'undefined' ? self : 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] = {
|
/******/ i: moduleId,
|
/******/ l: false,
|
/******/ exports: {}
|
/******/ };
|
/******/
|
/******/ // Execute the module function
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
/******/
|
/******/ // Flag the module as loaded
|
/******/ module.l = 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;
|
/******/
|
/******/ // define getter function for harmony exports
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
/******/ Object.defineProperty(exports, name, {
|
/******/ configurable: false,
|
/******/ enumerable: true,
|
/******/ get: getter
|
/******/ });
|
/******/ }
|
/******/ };
|
/******/
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
/******/ __webpack_require__.n = function(module) {
|
/******/ var getter = module && module.__esModule ?
|
/******/ function getDefault() { return module['default']; } :
|
/******/ function getModuleExports() { return module; };
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
/******/ return getter;
|
/******/ };
|
/******/
|
/******/ // Object.prototype.hasOwnProperty.call
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
/******/
|
/******/ // __webpack_public_path__
|
/******/ __webpack_require__.p = "";
|
/******/
|
/******/ // Load entry module and return exports
|
/******/ return __webpack_require__(__webpack_require__.s = 31);
|
/******/ })
|
/************************************************************************/
|
/******/ ({
|
|
/***/ 10:
|
/***/ (function(module, exports, __webpack_require__) {
|
|
"use strict";
|
/* WEBPACK VAR INJECTION */(function(global) {
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.Centrifuge = 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 _events = __webpack_require__(6);
|
|
var _events2 = _interopRequireDefault(_events);
|
|
var _subscription = __webpack_require__(11);
|
|
var _subscription2 = _interopRequireDefault(_subscription);
|
|
var _json = __webpack_require__(12);
|
|
var _utils = __webpack_require__(7);
|
|
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 _errorTimeout = 'timeout';
|
var _errorConnectionClosed = 'connection closed';
|
|
var Centrifuge = exports.Centrifuge = function (_EventEmitter) {
|
_inherits(Centrifuge, _EventEmitter);
|
|
function Centrifuge(url, options) {
|
_classCallCheck(this, Centrifuge);
|
|
var _this = _possibleConstructorReturn(this, (Centrifuge.__proto__ || Object.getPrototypeOf(Centrifuge)).call(this));
|
|
_this._url = url;
|
_this._websocket = null;
|
_this._sockjs = null;
|
_this._isSockjs = false;
|
_this._binary = false;
|
_this._methodType = null;
|
_this._pushType = null;
|
_this._encoder = null;
|
_this._decoder = null;
|
_this._status = 'disconnected';
|
_this._reconnect = true;
|
_this._reconnecting = false;
|
_this._transport = null;
|
_this._transportName = null;
|
_this._transportClosed = true;
|
_this._messageId = 0;
|
_this._clientID = null;
|
_this._refreshRequired = false;
|
_this._subs = {};
|
_this._serverSubs = {};
|
_this._lastSeq = {};
|
_this._lastGen = {};
|
_this._lastEpoch = {};
|
_this._messages = [];
|
_this._isBatching = false;
|
_this._isSubscribeBatching = false;
|
_this._privateChannels = {};
|
_this._numRefreshFailed = 0;
|
_this._refreshTimeout = null;
|
_this._pingTimeout = null;
|
_this._pongTimeout = null;
|
_this._subRefreshTimeouts = {};
|
_this._retries = 0;
|
_this._callbacks = {};
|
_this._latency = null;
|
_this._latencyStart = null;
|
_this._connectData = null;
|
_this._token = null;
|
_this._xhrID = 0;
|
_this._xhrs = {};
|
_this._config = {
|
debug: false,
|
websocket: null,
|
sockjs: null,
|
promise: null,
|
minRetry: 1000,
|
maxRetry: 20000,
|
timeout: 5000,
|
ping: true,
|
pingInterval: 25000,
|
pongWaitTimeout: 5000,
|
privateChannelPrefix: '$',
|
onTransportClose: null,
|
sockjsServer: null,
|
sockjsTransports: ['websocket', 'xdr-streaming', 'xhr-streaming', 'eventsource', 'iframe-eventsource', 'iframe-htmlfile', 'xdr-polling', 'xhr-polling', 'iframe-xhr-polling', 'jsonp-polling'],
|
refreshEndpoint: '/centrifuge/refresh',
|
refreshHeaders: {},
|
refreshParams: {},
|
refreshData: {},
|
refreshAttempts: null,
|
refreshInterval: 1000,
|
onRefreshFailed: null,
|
onRefresh: null,
|
subscribeEndpoint: '/centrifuge/subscribe',
|
subscribeHeaders: {},
|
subscribeParams: {},
|
subRefreshInterval: 1000,
|
onPrivateSubscribe: null
|
};
|
_this._configure(options);
|
return _this;
|
}
|
|
_createClass(Centrifuge, [{
|
key: 'setToken',
|
value: function setToken(token) {
|
this._token = token;
|
}
|
}, {
|
key: 'setConnectData',
|
value: function setConnectData(data) {
|
this._connectData = data;
|
}
|
}, {
|
key: 'setRefreshHeaders',
|
value: function setRefreshHeaders(headers) {
|
this._config.refreshHeaders = headers;
|
}
|
}, {
|
key: 'setRefreshParams',
|
value: function setRefreshParams(params) {
|
this._config.refreshParams = params;
|
}
|
}, {
|
key: 'setRefreshData',
|
value: function setRefreshData(data) {
|
this._config.refreshData = data;
|
}
|
}, {
|
key: 'setSubscribeHeaders',
|
value: function setSubscribeHeaders(headers) {
|
this._config.subscribeHeaders = headers;
|
}
|
}, {
|
key: 'setSubscribeParams',
|
value: function setSubscribeParams(params) {
|
this._config.subscribeParams = params;
|
}
|
}, {
|
key: '_ajax',
|
value: function _ajax(url, params, headers, data, callback) {
|
var _this2 = this;
|
|
var query = '';
|
this._debug('sending AJAX request to', url, 'with data', JSON.stringify(data));
|
|
var xhr = global.XMLHttpRequest ? new global.XMLHttpRequest() : new global.ActiveXObject('Microsoft.XMLHTTP');
|
|
for (var i in params) {
|
if (params.hasOwnProperty(i)) {
|
if (query.length > 0) {
|
query += '&';
|
}
|
query += encodeURIComponent(i) + '=' + encodeURIComponent(params[i]);
|
}
|
}
|
if (query.length > 0) {
|
query = '?' + query;
|
}
|
xhr.open('POST', url + query, true);
|
if ('withCredentials' in xhr) {
|
xhr.withCredentials = true;
|
}
|
|
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
|
xhr.setRequestHeader('Content-Type', 'application/json');
|
for (var headerName in headers) {
|
if (headers.hasOwnProperty(headerName)) {
|
xhr.setRequestHeader(headerName, headers[headerName]);
|
}
|
}
|
|
xhr.onreadystatechange = function () {
|
if (xhr.readyState === 4) {
|
if (xhr.status === 200) {
|
var _data = void 0,
|
parsed = false;
|
try {
|
_data = JSON.parse(xhr.responseText);
|
parsed = true;
|
} catch (e) {
|
callback({
|
error: 'Invalid JSON. Data was: ' + xhr.responseText,
|
status: 200,
|
data: null
|
});
|
}
|
if (parsed) {
|
// prevents double execution.
|
callback({
|
data: _data,
|
status: 200
|
});
|
}
|
} else {
|
_this2._log('wrong status code in AJAX response', xhr.status);
|
callback({
|
status: xhr.status,
|
data: null
|
});
|
}
|
}
|
};
|
setTimeout(function () {
|
return xhr.send(JSON.stringify(data));
|
}, 20);
|
return xhr;
|
}
|
}, {
|
key: '_log',
|
value: function _log() {
|
(0, _utils.log)('info', arguments);
|
}
|
}, {
|
key: '_debug',
|
value: function _debug() {
|
if (this._config.debug === true) {
|
(0, _utils.log)('debug', arguments);
|
}
|
}
|
}, {
|
key: '_websocketSupported',
|
value: function _websocketSupported() {
|
if (this._config.websocket !== null) {
|
return true;
|
}
|
return !(typeof WebSocket !== 'function' && (typeof WebSocket === 'undefined' ? 'undefined' : _typeof(WebSocket)) !== 'object');
|
}
|
}, {
|
key: '_setFormat',
|
value: function _setFormat(format) {
|
if (this._formatOverride(format)) {
|
return;
|
}
|
if (format === 'protobuf') {
|
throw new Error('not implemented by JSON only Centrifuge client – use client with Protobuf');
|
}
|
this._binary = false;
|
this._methodType = _json.JsonMethodType;
|
this._pushType = _json.JsonPushType;
|
this._encoder = new _json.JsonEncoder();
|
this._decoder = new _json.JsonDecoder();
|
}
|
}, {
|
key: '_formatOverride',
|
value: function _formatOverride(format) {
|
return false;
|
}
|
}, {
|
key: '_configure',
|
value: function _configure(configuration) {
|
if (!('Promise' in global)) {
|
throw new Error('Promise polyfill required');
|
}
|
|
(0, _utils.extend)(this._config, configuration || {});
|
this._debug('centrifuge config', this._config);
|
|
if (!this._url) {
|
throw new Error('url required');
|
}
|
|
if ((0, _utils.startsWith)(this._url, 'ws') && this._url.indexOf('format=protobuf') > -1) {
|
this._setFormat('protobuf');
|
} else {
|
this._setFormat('json');
|
}
|
|
if ((0, _utils.startsWith)(this._url, 'http')) {
|
this._debug('client will try to connect to SockJS endpoint');
|
if (this._config.sockjs !== null) {
|
this._debug('SockJS explicitly provided in options');
|
this._sockjs = this._config.sockjs;
|
} else {
|
if (typeof global.SockJS === 'undefined') {
|
throw new Error('SockJS not found, use ws:// in url or include SockJS');
|
}
|
this._debug('use globally defined SockJS');
|
this._sockjs = global.SockJS;
|
}
|
} else {
|
this._debug('client will connect to websocket endpoint');
|
}
|
}
|
}, {
|
key: '_setStatus',
|
value: function _setStatus(newStatus) {
|
if (this._status !== newStatus) {
|
this._debug('Status', this._status, '->', newStatus);
|
this._status = newStatus;
|
}
|
}
|
}, {
|
key: '_isDisconnected',
|
value: function _isDisconnected() {
|
return this._status === 'disconnected';
|
}
|
}, {
|
key: '_isConnecting',
|
value: function _isConnecting() {
|
return this._status === 'connecting';
|
}
|
}, {
|
key: '_isConnected',
|
value: function _isConnected() {
|
return this._status === 'connected';
|
}
|
}, {
|
key: '_nextMessageId',
|
value: function _nextMessageId() {
|
return ++this._messageId;
|
}
|
}, {
|
key: '_resetRetry',
|
value: function _resetRetry() {
|
this._debug('reset retries count to 0');
|
this._retries = 0;
|
}
|
}, {
|
key: '_getRetryInterval',
|
value: function _getRetryInterval() {
|
var interval = (0, _utils.backoff)(this._retries, this._config.minRetry, this._config.maxRetry);
|
|
this._retries += 1;
|
return interval;
|
}
|
}, {
|
key: '_abortInflightXHRs',
|
value: function _abortInflightXHRs() {
|
for (var xhrID in this._xhrs) {
|
try {
|
this._xhrs[xhrID].abort();
|
} catch (e) {
|
this._debug('error aborting xhr', e);
|
}
|
delete this._xhrs[xhrID];
|
}
|
}
|
}, {
|
key: '_clearConnectedState',
|
value: function _clearConnectedState(reconnect) {
|
this._clientID = null;
|
this._stopPing();
|
|
// fire errbacks of registered outgoing calls.
|
for (var id in this._callbacks) {
|
if (this._callbacks.hasOwnProperty(id)) {
|
var callbacks = this._callbacks[id];
|
clearTimeout(callbacks.timeout);
|
var errback = callbacks.errback;
|
if (!errback) {
|
continue;
|
}
|
errback({ error: this._createErrorObject('disconnected') });
|
}
|
}
|
this._callbacks = {};
|
|
// fire unsubscribe events
|
for (var channel in this._subs) {
|
if (this._subs.hasOwnProperty(channel)) {
|
var sub = this._subs[channel];
|
|
if (reconnect) {
|
if (sub._isSuccess()) {
|
sub._triggerUnsubscribe();
|
sub._recover = true;
|
}
|
if (sub._shouldResubscribe()) {
|
sub._setSubscribing();
|
}
|
} else {
|
sub._setUnsubscribed();
|
}
|
}
|
}
|
|
this._abortInflightXHRs();
|
|
// clear refresh timer
|
if (this._refreshTimeout !== null) {
|
clearTimeout(this._refreshTimeout);
|
this._refreshTimeout = null;
|
}
|
|
// clear sub refresh timers
|
for (var _channel in this._subRefreshTimeouts) {
|
if (this._subRefreshTimeouts.hasOwnProperty(_channel) && this._subRefreshTimeouts[_channel]) {
|
this._clearSubRefreshTimeout(_channel);
|
}
|
}
|
this._subRefreshTimeouts = {};
|
|
if (!this._reconnect) {
|
// completely clear subscriptions
|
this._subs = {};
|
}
|
}
|
}, {
|
key: '_isTransportOpen',
|
value: function _isTransportOpen() {
|
if (this._isSockjs) {
|
return this._transport && this._transport.transport && this._transport.transport.readyState === this._transport.transport.OPEN;
|
}
|
return this._transport && this._transport.readyState === this._transport.OPEN;
|
}
|
}, {
|
key: '_transportSend',
|
value: function _transportSend(commands) {
|
if (!commands.length) {
|
return true;
|
}
|
|
if (!this._isTransportOpen()) {
|
// resolve pending commands with error if transport is not open
|
for (var command in commands) {
|
var id = command.id;
|
if (!(id in this._callbacks)) {
|
continue;
|
}
|
var callbacks = this._callbacks[id];
|
clearTimeout(this._callbacks[id].timeout);
|
delete this._callbacks[id];
|
var errback = callbacks.errback;
|
errback({ error: this._createErrorObject(_errorConnectionClosed, 0) });
|
}
|
return false;
|
}
|
this._transport.send(this._encoder.encodeCommands(commands));
|
return true;
|
}
|
}, {
|
key: '_setupTransport',
|
value: function _setupTransport() {
|
var _this3 = this;
|
|
this._isSockjs = false;
|
|
// detect transport to use - SockJS or Websocket
|
if (this._sockjs !== null) {
|
var sockjsOptions = {
|
transports: this._config.sockjsTransports
|
};
|
|
if (this._config.sockjsServer !== null) {
|
sockjsOptions.server = this._config.sockjsServer;
|
}
|
this._isSockjs = true;
|
this._transport = new this._sockjs(this._url, null, sockjsOptions);
|
} else {
|
if (!this._websocketSupported()) {
|
this._debug('No Websocket support and no SockJS configured, can not connect');
|
return;
|
}
|
if (this._config.websocket !== null) {
|
this._websocket = this._config.websocket;
|
} else {
|
this._websocket = WebSocket;
|
}
|
this._transport = new this._websocket(this._url);
|
if (this._binary === true) {
|
this._transport.binaryType = 'arraybuffer';
|
}
|
}
|
|
this._transport.onopen = function () {
|
_this3._transportClosed = false;
|
|
if (_this3._isSockjs) {
|
_this3._transportName = 'sockjs-' + _this3._transport.transport;
|
_this3._transport.onheartbeat = function () {
|
return _this3._restartPing();
|
};
|
} else {
|
_this3._transportName = 'websocket';
|
}
|
|
// Can omit method here due to zero value.
|
var msg = {
|
// method: this._methodType.CONNECT
|
};
|
|
if (_this3._token || _this3._connectData) {
|
msg.params = {};
|
}
|
|
if (_this3._token) {
|
msg.params.token = _this3._token;
|
}
|
|
if (_this3._connectData) {
|
msg.params.data = _this3._connectData;
|
}
|
|
var subs = {};
|
var hasSubs = false;
|
for (var channel in _this3._serverSubs) {
|
if (_this3._serverSubs.hasOwnProperty(channel) && _this3._serverSubs[channel].recoverable) {
|
hasSubs = true;
|
var sub = {
|
'recover': true
|
};
|
if (_this3._serverSubs[channel].seq) {
|
sub['seq'] = _this3._serverSubs[channel].seq;
|
}
|
if (_this3._serverSubs[channel].gen) {
|
sub['gen'] = _this3._serverSubs[channel].gen;
|
}
|
if (_this3._serverSubs[channel].epoch) {
|
sub['epoch'] = _this3._serverSubs[channel].epoch;
|
}
|
subs[channel] = sub;
|
}
|
}
|
if (hasSubs) {
|
if (!msg.params) {
|
msg.params = {};
|
}
|
msg.params.subs = subs;
|
}
|
|
_this3._latencyStart = new Date();
|
_this3._call(msg).then(function (resolveCtx) {
|
_this3._connectResponse(_this3._decoder.decodeCommandResult(_this3._methodType.CONNECT, resolveCtx.result), hasSubs);
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
var err = rejectCtx.error;
|
if (err.code === 109) {
|
// token expired.
|
_this3._refreshRequired = true;
|
}
|
_this3._disconnect('connect error', true);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
};
|
|
this._transport.onerror = function (error) {
|
_this3._debug('transport level error', error);
|
};
|
|
this._transport.onclose = function (closeEvent) {
|
_this3._transportClosed = true;
|
var reason = _errorConnectionClosed;
|
var needReconnect = true;
|
|
if (closeEvent && 'reason' in closeEvent && closeEvent.reason) {
|
try {
|
var advice = JSON.parse(closeEvent.reason);
|
_this3._debug('reason is an advice object', advice);
|
reason = advice.reason;
|
needReconnect = advice.reconnect;
|
} catch (e) {
|
reason = closeEvent.reason;
|
_this3._debug('reason is a plain string', reason);
|
}
|
}
|
|
// onTransportClose callback should be executed every time transport was closed.
|
// This can be helpful to catch failed connection events (because our disconnect
|
// event only called once and every future attempts to connect do not fire disconnect
|
// event again).
|
if (_this3._config.onTransportClose !== null) {
|
_this3._config.onTransportClose({
|
event: closeEvent,
|
reason: reason,
|
reconnect: needReconnect
|
});
|
}
|
|
_this3._disconnect(reason, needReconnect);
|
|
if (_this3._reconnect === true) {
|
_this3._reconnecting = true;
|
var interval = _this3._getRetryInterval();
|
|
_this3._debug('reconnect after ' + interval + ' milliseconds');
|
setTimeout(function () {
|
if (_this3._reconnect === true) {
|
if (_this3._refreshRequired) {
|
_this3._refresh();
|
} else {
|
_this3._connect();
|
}
|
}
|
}, interval);
|
}
|
};
|
|
this._transport.onmessage = function (event) {
|
_this3._dataReceived(event.data);
|
};
|
}
|
}, {
|
key: 'rpc',
|
value: function rpc(data) {
|
var _this4 = this;
|
|
var msg = {
|
method: this._methodType.RPC,
|
params: {
|
data: data
|
}
|
};
|
|
if (!this.isConnected()) {
|
return Promise.reject(this._createErrorObject(_errorConnectionClosed, 0));
|
}
|
|
return this._call(msg).then(function (resolveCtx) {
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
return _this4._decoder.decodeCommandResult(_this4._methodType.RPC, resolveCtx.result);
|
}, function (rejectCtx) {
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
return Promise.reject(rejectCtx.error);
|
});
|
}
|
}, {
|
key: 'send',
|
value: function send(data) {
|
var msg = {
|
method: this._methodType.SEND,
|
params: {
|
data: data
|
}
|
};
|
|
if (!this.isConnected()) {
|
return Promise.reject(this._createErrorObject(_errorConnectionClosed, 0));
|
}
|
|
var sent = this._transportSend([msg]); // can send async message to server without id set
|
if (!sent) {
|
return Promise.reject(this._createErrorObject(_errorConnectionClosed, 0));
|
};
|
return Promise.resolve({});
|
}
|
}, {
|
key: 'publish',
|
value: function publish(channel, data) {
|
var msg = {
|
method: this._methodType.PUBLISH,
|
params: {
|
channel: channel,
|
data: data
|
}
|
};
|
|
if (!this.isConnected()) {
|
return Promise.reject(this._createErrorObject(_errorConnectionClosed, 0));
|
}
|
|
return this._call(msg).then(function (result) {
|
if (result.next) {
|
result.next();
|
}
|
return {};
|
});
|
}
|
}, {
|
key: '_dataReceived',
|
value: function _dataReceived(data) {
|
var _this5 = this;
|
|
var replies = this._decoder.decodeReplies(data);
|
// we have to guarantee order of events in replies processing - i.e. start processing
|
// next reply only when we finished processing of current one. Without syncing things in
|
// this way we could get wrong publication events order as reply promises resolve
|
// on next loop tick so for loop continues before we finished emitting all reply events.
|
var p = Promise.resolve();
|
|
var _loop = function _loop(i) {
|
if (replies.hasOwnProperty(i)) {
|
p = p.then(function () {
|
return _this5._dispatchReply(replies[i]);
|
});
|
}
|
};
|
|
for (var i in replies) {
|
_loop(i);
|
}
|
this._restartPing();
|
}
|
}, {
|
key: '_call',
|
value: function _call(msg) {
|
var _this6 = this;
|
|
return new Promise(function (resolve, reject) {
|
var id = _this6._addMessage(msg);
|
_this6._registerCall(id, resolve, reject);
|
});
|
}
|
}, {
|
key: '_connect',
|
value: function _connect() {
|
if (this.isConnected()) {
|
this._debug('connect called when already connected');
|
return;
|
}
|
if (this._status === 'connecting') {
|
return;
|
}
|
|
this._debug('start connecting');
|
this._setStatus('connecting');
|
this._clientID = null;
|
this._reconnect = true;
|
this._setupTransport();
|
}
|
}, {
|
key: '_disconnect',
|
value: function _disconnect(reason, shouldReconnect) {
|
|
var reconnect = shouldReconnect || false;
|
if (reconnect === false) {
|
this._reconnect = false;
|
}
|
|
if (this._isDisconnected()) {
|
if (!reconnect) {
|
this._clearConnectedState(reconnect);
|
}
|
return;
|
}
|
|
this._clearConnectedState(reconnect);
|
|
this._debug('disconnected:', reason, shouldReconnect);
|
this._setStatus('disconnected');
|
|
if (this._refreshTimeout) {
|
clearTimeout(this._refreshTimeout);
|
this._refreshTimeout = null;
|
}
|
if (this._reconnecting === false) {
|
// fire unsubscribe events for server side subs.
|
for (var channel in this._serverSubs) {
|
if (this._serverSubs.hasOwnProperty(channel)) {
|
this.emit('unsubscribe', { channel: channel });
|
}
|
}
|
this.emit('disconnect', {
|
reason: reason,
|
reconnect: reconnect
|
});
|
}
|
|
if (reconnect === false) {
|
this._subs = {};
|
this._serverSubs = {};
|
}
|
|
if (!this._transportClosed) {
|
this._transport.close();
|
}
|
}
|
}, {
|
key: '_refreshFailed',
|
value: function _refreshFailed() {
|
this._numRefreshFailed = 0;
|
if (!this._isDisconnected()) {
|
this._disconnect('refresh failed', false);
|
}
|
if (this._config.onRefreshFailed !== null) {
|
this._config.onRefreshFailed();
|
}
|
}
|
}, {
|
key: '_refresh',
|
value: function _refresh() {
|
var _this7 = this;
|
|
// ask application for new connection token.
|
this._debug('refresh token');
|
|
if (this._config.refreshAttempts === 0) {
|
this._debug('refresh attempts set to 0, do not send refresh request at all');
|
this._refreshFailed();
|
return;
|
}
|
|
if (this._refreshTimeout !== null) {
|
clearTimeout(this._refreshTimeout);
|
this._refreshTimeout = null;
|
}
|
|
var clientID = this._clientID;
|
var xhrID = this._newXHRID();
|
|
var cb = function cb(resp) {
|
if (xhrID in _this7._xhrs) {
|
delete _this7._xhrs[xhrID];
|
}
|
if (_this7._clientID !== clientID) {
|
return;
|
}
|
if (resp.error || resp.status !== 200) {
|
// We don't perform any connection status related actions here as we are
|
// relying on server that must close connection eventually.
|
if (resp.error) {
|
_this7._debug('error refreshing connection token', resp.error);
|
} else {
|
_this7._debug('error refreshing connection token: wrong status code', resp.status);
|
}
|
_this7._numRefreshFailed++;
|
if (_this7._refreshTimeout !== null) {
|
clearTimeout(_this7._refreshTimeout);
|
_this7._refreshTimeout = null;
|
}
|
if (_this7._config.refreshAttempts !== null && _this7._numRefreshFailed >= _this7._config.refreshAttempts) {
|
_this7._refreshFailed();
|
return;
|
}
|
var jitter = Math.round(Math.random() * 1000 * Math.max(_this7._numRefreshFailed, 20));
|
var interval = _this7._config.refreshInterval + jitter;
|
_this7._refreshTimeout = setTimeout(function () {
|
return _this7._refresh();
|
}, interval);
|
return;
|
}
|
_this7._numRefreshFailed = 0;
|
_this7._token = resp.data.token;
|
if (!_this7._token) {
|
_this7._refreshFailed();
|
return;
|
}
|
if (_this7._isDisconnected() && _this7._reconnect) {
|
_this7._debug('token refreshed, connect from scratch');
|
_this7._connect();
|
} else {
|
_this7._debug('send refreshed token');
|
var msg = {
|
method: _this7._methodType.REFRESH,
|
params: {
|
token: _this7._token
|
}
|
};
|
_this7._call(msg).then(function (resolveCtx) {
|
_this7._refreshResponse(_this7._decoder.decodeCommandResult(_this7._methodType.REFRESH, resolveCtx.result));
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
_this7._refreshError(rejectCtx.error);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
}
|
};
|
|
if (this._config.onRefresh !== null) {
|
var context = {};
|
this._config.onRefresh(context, cb);
|
} else {
|
var xhr = this._ajax(this._config.refreshEndpoint, this._config.refreshParams, this._config.refreshHeaders, this._config.refreshData, cb);
|
this._xhrs[xhrID] = xhr;
|
}
|
}
|
}, {
|
key: '_refreshError',
|
value: function _refreshError(err) {
|
var _this8 = this;
|
|
this._debug('refresh error', err);
|
if (this._refreshTimeout) {
|
clearTimeout(this._refreshTimeout);
|
this._refreshTimeout = null;
|
}
|
var interval = this._config.refreshInterval + Math.round(Math.random() * 1000);
|
this._refreshTimeout = setTimeout(function () {
|
return _this8._refresh();
|
}, interval);
|
}
|
}, {
|
key: '_refreshResponse',
|
value: function _refreshResponse(result) {
|
var _this9 = this;
|
|
if (this._refreshTimeout) {
|
clearTimeout(this._refreshTimeout);
|
this._refreshTimeout = null;
|
}
|
if (result.expires) {
|
this._clientID = result.client;
|
this._refreshTimeout = setTimeout(function () {
|
return _this9._refresh();
|
}, this._getTTLMilliseconds(result.ttl));
|
}
|
}
|
}, {
|
key: '_newXHRID',
|
value: function _newXHRID() {
|
this._xhrID++;
|
return this._xhrID;
|
}
|
}, {
|
key: '_subRefresh',
|
value: function _subRefresh(channel) {
|
var _this10 = this;
|
|
this._debug('refresh subscription token for channel', channel);
|
|
if (this._subRefreshTimeouts[channel] !== undefined) {
|
this._clearSubRefreshTimeout(channel);
|
} else {
|
return;
|
}
|
|
var clientID = this._clientID;
|
var xhrID = this._newXHRID();
|
|
var cb = function cb(resp) {
|
if (xhrID in _this10._xhrs) {
|
delete _this10._xhrs[xhrID];
|
}
|
if (resp.error || resp.status !== 200 || _this10._clientID !== clientID) {
|
return;
|
}
|
var channelsData = {};
|
if (resp.data.channels) {
|
for (var i in data.channels) {
|
var channelData = resp.data.channels[i];
|
if (!channelData.channel) {
|
continue;
|
}
|
channelsData[channelData.channel] = channelData.token;
|
}
|
}
|
|
var token = channelsData[channel];
|
if (!token) {
|
return;
|
}
|
var msg = {
|
method: _this10._methodType.SUB_REFRESH,
|
params: {
|
channel: channel,
|
token: token
|
}
|
};
|
|
var sub = _this10._getSub(channel);
|
if (sub === null) {
|
return;
|
}
|
|
_this10._call(msg).then(function (resolveCtx) {
|
_this10._subRefreshResponse(channel, _this10._decoder.decodeCommandResult(_this10._methodType.SUB_REFRESH, resolveCtx.result));
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
_this10._subRefreshError(channel, rejectCtx.error);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
};
|
|
var data = {
|
client: this._clientID,
|
channels: [channel]
|
};
|
|
if (this._config.onPrivateSubscribe !== null) {
|
this._config.onPrivateSubscribe({
|
data: data
|
}, cb);
|
} else {
|
var xhr = this._ajax(this._config.subscribeEndpoint, this._config.subscribeParams, this._config.subscribeHeaders, data, cb);
|
this._xhrs[xhrID] = xhr;
|
}
|
}
|
}, {
|
key: '_clearSubRefreshTimeout',
|
value: function _clearSubRefreshTimeout(channel) {
|
if (this._subRefreshTimeouts[channel] !== undefined) {
|
clearTimeout(this._subRefreshTimeouts[channel]);
|
delete this._subRefreshTimeouts[channel];
|
}
|
}
|
}, {
|
key: '_subRefreshError',
|
value: function _subRefreshError(channel, err) {
|
var _this11 = this;
|
|
this._debug('subscription refresh error', channel, err);
|
this._clearSubRefreshTimeout(channel);
|
var sub = this._getSub(channel);
|
if (sub === null) {
|
return;
|
}
|
var jitter = Math.round(Math.random() * 1000);
|
var subRefreshTimeout = setTimeout(function () {
|
return _this11._subRefresh(channel);
|
}, this._config.subRefreshInterval + jitter);
|
this._subRefreshTimeouts[channel] = subRefreshTimeout;
|
return;
|
}
|
}, {
|
key: '_subRefreshResponse',
|
value: function _subRefreshResponse(channel, result) {
|
var _this12 = this;
|
|
this._debug('subscription refresh success', channel);
|
this._clearSubRefreshTimeout(channel);
|
var sub = this._getSub(channel);
|
if (sub === null) {
|
return;
|
}
|
if (result.expires === true) {
|
var subRefreshTimeout = setTimeout(function () {
|
return _this12._subRefresh(channel);
|
}, this._getTTLMilliseconds(result.ttl));
|
this._subRefreshTimeouts[channel] = subRefreshTimeout;
|
}
|
return;
|
}
|
}, {
|
key: '_subscribe',
|
value: function _subscribe(sub, isResubscribe) {
|
var _this13 = this;
|
|
this._debug('subscribing on', sub.channel);
|
var channel = sub.channel;
|
|
if (!(channel in this._subs)) {
|
this._subs[channel] = sub;
|
}
|
|
if (!this.isConnected()) {
|
// subscribe will be called later
|
sub._setNew();
|
return;
|
}
|
|
sub._setSubscribing(isResubscribe);
|
|
var msg = {
|
method: this._methodType.SUBSCRIBE,
|
params: {
|
channel: channel
|
}
|
};
|
|
// If channel name does not start with privateChannelPrefix - then we
|
// can just send subscription message to Centrifuge. If channel name
|
// starts with privateChannelPrefix - then this is a private channel
|
// and we should ask web application backend for permission first.
|
if ((0, _utils.startsWith)(channel, this._config.privateChannelPrefix)) {
|
// private channel.
|
if (this._isSubscribeBatching) {
|
this._privateChannels[channel] = true;
|
} else {
|
this.startSubscribeBatching();
|
this._subscribe(sub);
|
this.stopSubscribeBatching();
|
}
|
} else {
|
var recover = sub._needRecover();
|
|
if (recover === true) {
|
msg.params.recover = true;
|
var seq = this._getLastSeq(channel);
|
if (seq) {
|
msg.params.seq = seq;
|
}
|
var gen = this._getLastGen(channel);
|
if (gen) {
|
msg.params.gen = gen;
|
}
|
var epoch = this._getLastEpoch(channel);
|
if (epoch) {
|
msg.params.epoch = epoch;
|
}
|
}
|
|
this._call(msg).then(function (resolveCtx) {
|
_this13._subscribeResponse(channel, recover, _this13._decoder.decodeCommandResult(_this13._methodType.SUBSCRIBE, resolveCtx.result));
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
_this13._subscribeError(channel, rejectCtx.error);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
}
|
}
|
}, {
|
key: '_unsubscribe',
|
value: function _unsubscribe(sub) {
|
if (this.isConnected()) {
|
// No need to unsubscribe in disconnected state - i.e. client already unsubscribed.
|
this._addMessage({
|
method: this._methodType.UNSUBSCRIBE,
|
params: {
|
channel: sub.channel
|
}
|
});
|
}
|
}
|
}, {
|
key: '_getTTLMilliseconds',
|
value: function _getTTLMilliseconds(ttl) {
|
// https://stackoverflow.com/questions/12633405/what-is-the-maximum-delay-for-setinterval
|
return Math.min(ttl * 1000, 2147483647);
|
}
|
}, {
|
key: 'getSub',
|
value: function getSub(channel) {
|
return this._getSub(channel);
|
}
|
}, {
|
key: '_getSub',
|
value: function _getSub(channel) {
|
var sub = this._subs[channel];
|
if (!sub) {
|
return null;
|
}
|
return sub;
|
}
|
}, {
|
key: '_connectResponse',
|
value: function _connectResponse(result, isRecover) {
|
var _this14 = this;
|
|
var wasReconnecting = this._reconnecting;
|
this._reconnecting = false;
|
this._resetRetry();
|
this._refreshRequired = false;
|
|
if (this.isConnected()) {
|
return;
|
}
|
|
if (this._latencyStart !== null) {
|
this._latency = new Date().getTime() - this._latencyStart.getTime();
|
this._latencyStart = null;
|
}
|
|
this._clientID = result.client;
|
this._setStatus('connected');
|
|
if (this._refreshTimeout) {
|
clearTimeout(this._refreshTimeout);
|
}
|
|
if (result.expires) {
|
this._refreshTimeout = setTimeout(function () {
|
return _this14._refresh();
|
}, this._getTTLMilliseconds(result.ttl));
|
}
|
|
this.startBatching();
|
this.startSubscribeBatching();
|
for (var channel in this._subs) {
|
if (this._subs.hasOwnProperty(channel)) {
|
var sub = this._subs[channel];
|
if (sub._shouldResubscribe()) {
|
this._subscribe(sub, wasReconnecting);
|
}
|
}
|
}
|
this.stopSubscribeBatching();
|
this.stopBatching();
|
|
this._startPing();
|
|
var ctx = {
|
client: result.client,
|
transport: this._transportName,
|
latency: this._latency
|
};
|
if (result.data) {
|
ctx.data = result.data;
|
}
|
|
this.emit('connect', ctx);
|
|
if (result.subs) {
|
this._processServerSubs(result.subs, isRecover);
|
}
|
}
|
}, {
|
key: '_processServerSubs',
|
value: function _processServerSubs(subs, isRecover) {
|
for (var channel in subs) {
|
if (subs.hasOwnProperty(channel)) {
|
var sub = subs[channel];
|
var recovered = sub.recovered === true;
|
var subCtx = { channel: channel, isResubscribe: isRecover, recovered: recovered };
|
this.emit('subscribe', subCtx);
|
}
|
}
|
for (var _channel2 in subs) {
|
if (subs.hasOwnProperty(_channel2)) {
|
var _sub = subs[_channel2];
|
if (_sub.recovered) {
|
var pubs = _sub.publications;
|
if (pubs && pubs.length > 0) {
|
pubs = pubs.reverse();
|
for (var i in pubs) {
|
if (pubs.hasOwnProperty(i)) {
|
this._handlePublication(_channel2, pubs[i]);
|
}
|
}
|
}
|
}
|
this._serverSubs[_channel2] = {
|
'seq': _sub.seq,
|
'gen': _sub.gen,
|
'epoch': _sub.epoch,
|
'recoverable': _sub.recoverable
|
};
|
}
|
}
|
}
|
}, {
|
key: '_stopPing',
|
value: function _stopPing() {
|
if (this._pongTimeout !== null) {
|
clearTimeout(this._pongTimeout);
|
this._pongTimeout = null;
|
}
|
if (this._pingTimeout !== null) {
|
clearTimeout(this._pingTimeout);
|
this._pingTimeout = null;
|
}
|
}
|
}, {
|
key: '_startPing',
|
value: function _startPing() {
|
var _this15 = this;
|
|
if (this._config.ping !== true || this._config.pingInterval <= 0) {
|
return;
|
}
|
if (!this.isConnected()) {
|
return;
|
}
|
|
this._pingTimeout = setTimeout(function () {
|
if (!_this15.isConnected()) {
|
_this15._stopPing();
|
return;
|
}
|
_this15.ping();
|
_this15._pongTimeout = setTimeout(function () {
|
_this15._disconnect('no ping', true);
|
}, _this15._config.pongWaitTimeout);
|
}, this._config.pingInterval);
|
}
|
}, {
|
key: '_restartPing',
|
value: function _restartPing() {
|
this._stopPing();
|
this._startPing();
|
}
|
}, {
|
key: '_subscribeError',
|
value: function _subscribeError(channel, error) {
|
var sub = this._getSub(channel);
|
if (!sub) {
|
return;
|
}
|
if (!sub._isSubscribing()) {
|
return;
|
}
|
if (error.code === 0 && error.message === _errorTimeout) {
|
// client side timeout.
|
this._disconnect('timeout', true);
|
return;
|
}
|
sub._setSubscribeError(error);
|
}
|
}, {
|
key: '_subscribeResponse',
|
value: function _subscribeResponse(channel, isRecover, result) {
|
var _this16 = this;
|
|
var sub = this._getSub(channel);
|
if (!sub) {
|
return;
|
}
|
if (!sub._isSubscribing()) {
|
return;
|
}
|
|
var recovered = false;
|
if ('recovered' in result) {
|
recovered = result.recovered;
|
}
|
sub._setSubscribeSuccess(recovered);
|
|
var pubs = result.publications;
|
if (pubs && pubs.length > 0) {
|
pubs = pubs.reverse();
|
for (var i in pubs) {
|
if (pubs.hasOwnProperty(i)) {
|
this._handlePublication(channel, pubs[i]);
|
}
|
}
|
}
|
|
if (result.recoverable && (!isRecover || !recovered)) {
|
this._lastSeq[channel] = result.seq || 0;
|
this._lastGen[channel] = result.gen || 0;
|
}
|
|
this._lastEpoch[channel] = result.epoch || '';
|
|
if (result.recoverable) {
|
sub._recoverable = true;
|
}
|
|
if (result.expires === true) {
|
var subRefreshTimeout = setTimeout(function () {
|
return _this16._subRefresh(channel);
|
}, this._getTTLMilliseconds(result.ttl));
|
this._subRefreshTimeouts[channel] = subRefreshTimeout;
|
}
|
}
|
}, {
|
key: '_handleReply',
|
value: function _handleReply(reply, next) {
|
var id = reply.id;
|
var result = reply.result;
|
|
if (!(id in this._callbacks)) {
|
next();
|
return;
|
}
|
var callbacks = this._callbacks[id];
|
clearTimeout(this._callbacks[id].timeout);
|
delete this._callbacks[id];
|
|
if (!(0, _utils.errorExists)(reply)) {
|
var callback = callbacks.callback;
|
if (!callback) {
|
return;
|
}
|
callback({ result: result, next: next });
|
} else {
|
var errback = callbacks.errback;
|
if (!errback) {
|
next();
|
return;
|
}
|
var error = reply.error;
|
errback({ error: error, next: next });
|
}
|
}
|
}, {
|
key: '_handleJoin',
|
value: function _handleJoin(channel, join) {
|
var ctx = { 'info': join.info };
|
var sub = this._getSub(channel);
|
if (!sub) {
|
ctx.channel = channel;
|
this.emit('join', ctx);
|
return;
|
}
|
sub.emit('join', ctx);
|
}
|
}, {
|
key: '_handleLeave',
|
value: function _handleLeave(channel, leave) {
|
var ctx = { 'info': leave.info };
|
var sub = this._getSub(channel);
|
if (!sub) {
|
ctx.channel = channel;
|
this.emit('leave', ctx);
|
return;
|
}
|
sub.emit('leave', ctx);
|
}
|
}, {
|
key: '_handleUnsub',
|
value: function _handleUnsub(channel, unsub) {
|
var ctx = {};
|
var sub = this._getSub(channel);
|
if (!sub) {
|
delete this._serverSubs[channel];
|
ctx.channel = channel;
|
this.emit('unsubscribe', ctx);
|
return;
|
}
|
sub.unsubscribe();
|
if (unsub.resubscribe === true) {
|
sub.subscribe();
|
}
|
}
|
}, {
|
key: '_handleSub',
|
value: function _handleSub(channel, sub) {
|
this._serverSubs[channel] = {
|
'seq': sub.seq,
|
'gen': sub.gen,
|
'epoch': sub.epoch,
|
'recoverable': sub.recoverable
|
};
|
var ctx = { 'channel': channel, isResubscribe: false, recovered: false };
|
this.emit('subscribe', ctx);
|
}
|
}, {
|
key: '_handlePublication',
|
value: function _handlePublication(channel, pub) {
|
var sub = this._getSub(channel);
|
var ctx = {
|
'data': pub.data,
|
'seq': pub.seq,
|
'gen': pub.gen
|
};
|
if (!sub) {
|
if (this._serverSubs[channel] !== undefined) {
|
if (pub.seq !== undefined) {
|
this._serverSubs[channel].seq = pub.seq;
|
}
|
if (pub.gen !== undefined) {
|
this._serverSubs[channel].gen = pub.gen;
|
}
|
}
|
ctx.channel = channel;
|
this.emit('publish', ctx);
|
return;
|
}
|
if (pub.seq !== undefined) {
|
this._lastSeq[channel] = pub.seq;
|
}
|
if (pub.gen !== undefined) {
|
this._lastGen[channel] = pub.gen;
|
}
|
sub.emit('publish', ctx);
|
}
|
}, {
|
key: '_handleMessage',
|
value: function _handleMessage(message) {
|
this.emit('message', message.data);
|
}
|
}, {
|
key: '_handlePush',
|
value: function _handlePush(data, next) {
|
var push = this._decoder.decodePush(data);
|
var type = 0;
|
if ('type' in push) {
|
type = push['type'];
|
}
|
var channel = push.channel;
|
|
if (type === this._pushType.PUBLICATION) {
|
var pub = this._decoder.decodePushData(this._pushType.PUBLICATION, push.data);
|
this._handlePublication(channel, pub);
|
} else if (type === this._pushType.MESSAGE) {
|
var message = this._decoder.decodePushData(this._pushType.MESSAGE, push.data);
|
this._handleMessage(message);
|
} else if (type === this._pushType.JOIN) {
|
var join = this._decoder.decodePushData(this._pushType.JOIN, push.data);
|
this._handleJoin(channel, join);
|
} else if (type === this._pushType.LEAVE) {
|
var leave = this._decoder.decodePushData(this._pushType.LEAVE, push.data);
|
this._handleLeave(channel, leave);
|
} else if (type === this._pushType.UNSUB) {
|
var unsub = this._decoder.decodePushData(this._pushType.UNSUB, push.data);
|
this._handleUnsub(channel, unsub);
|
} else if (type === this._pushType.SUB) {
|
var sub = this._decoder.decodePushData(this._pushType.SUB, push.data);
|
this._handleSub(channel, sub);
|
}
|
next();
|
}
|
}, {
|
key: '_dispatchReply',
|
value: function _dispatchReply(reply) {
|
var next;
|
var p = new Promise(function (resolve) {
|
next = resolve;
|
});
|
|
if (reply === undefined || reply === null) {
|
this._debug('dispatch: got undefined or null reply');
|
next();
|
return p;
|
}
|
|
var id = reply.id;
|
|
if (id && id > 0) {
|
this._handleReply(reply, next);
|
} else {
|
this._handlePush(reply.result, next);
|
}
|
|
return p;
|
}
|
}, {
|
key: '_flush',
|
value: function _flush() {
|
var messages = this._messages.slice(0);
|
this._messages = [];
|
this._transportSend(messages);
|
}
|
}, {
|
key: '_ping',
|
value: function _ping() {
|
var _this17 = this;
|
|
var msg = {
|
method: this._methodType.PING
|
};
|
this._call(msg).then(function (resolveCtx) {
|
_this17._pingResponse(_this17._decoder.decodeCommandResult(_this17._methodType.PING, resolveCtx.result));
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
_this17._debug('ping error', rejectCtx.error);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
}
|
}, {
|
key: '_pingResponse',
|
value: function _pingResponse(result) {
|
if (!this.isConnected()) {
|
return;
|
}
|
this._stopPing();
|
this._startPing();
|
}
|
}, {
|
key: '_getLastSeq',
|
value: function _getLastSeq(channel) {
|
var lastSeq = this._lastSeq[channel];
|
if (lastSeq) {
|
return lastSeq;
|
}
|
return 0;
|
}
|
}, {
|
key: '_getLastGen',
|
value: function _getLastGen(channel) {
|
var lastGen = this._lastGen[channel];
|
if (lastGen) {
|
return lastGen;
|
}
|
return 0;
|
}
|
}, {
|
key: '_getLastEpoch',
|
value: function _getLastEpoch(channel) {
|
var lastEpoch = this._lastEpoch[channel];
|
if (lastEpoch) {
|
return lastEpoch;
|
}
|
return '';
|
}
|
}, {
|
key: '_createErrorObject',
|
value: function _createErrorObject(message, code) {
|
var errObject = {
|
message: message,
|
code: code || 0
|
};
|
|
return errObject;
|
}
|
}, {
|
key: '_registerCall',
|
value: function _registerCall(id, callback, errback) {
|
var _this18 = this;
|
|
this._callbacks[id] = {
|
callback: callback,
|
errback: errback,
|
timeout: null
|
};
|
this._callbacks[id].timeout = setTimeout(function () {
|
delete _this18._callbacks[id];
|
if ((0, _utils.isFunction)(errback)) {
|
errback({ error: _this18._createErrorObject(_errorTimeout) });
|
}
|
}, this._config.timeout);
|
}
|
}, {
|
key: '_addMessage',
|
value: function _addMessage(message) {
|
var id = this._nextMessageId();
|
message.id = id;
|
if (this._isBatching === true) {
|
this._messages.push(message);
|
} else {
|
this._transportSend([message]);
|
}
|
return id;
|
}
|
}, {
|
key: 'isConnected',
|
value: function isConnected() {
|
return this._isConnected();
|
}
|
}, {
|
key: 'connect',
|
value: function connect() {
|
this._connect();
|
}
|
}, {
|
key: 'disconnect',
|
value: function disconnect() {
|
this._disconnect('client', false);
|
}
|
}, {
|
key: 'ping',
|
value: function ping() {
|
return this._ping();
|
}
|
}, {
|
key: 'startBatching',
|
value: function startBatching() {
|
// start collecting messages without sending them to Centrifuge until flush
|
// method called
|
this._isBatching = true;
|
}
|
}, {
|
key: 'stopBatching',
|
value: function stopBatching() {
|
this._isBatching = false;
|
this._flush();
|
}
|
}, {
|
key: 'startSubscribeBatching',
|
value: function startSubscribeBatching() {
|
// start collecting private channels to create bulk authentication
|
// request to subscribeEndpoint when stopSubscribeBatching will be called
|
this._isSubscribeBatching = true;
|
}
|
}, {
|
key: 'stopSubscribeBatching',
|
value: function stopSubscribeBatching() {
|
var _this19 = this;
|
|
// create request to subscribeEndpoint with collected private channels
|
// to ask if this client can subscribe on each channel
|
this._isSubscribeBatching = false;
|
var authChannels = this._privateChannels;
|
this._privateChannels = {};
|
|
var channels = [];
|
|
for (var channel in authChannels) {
|
if (authChannels.hasOwnProperty(channel)) {
|
var sub = this._getSub(channel);
|
if (!sub) {
|
continue;
|
}
|
channels.push(channel);
|
}
|
}
|
|
if (channels.length === 0) {
|
this._debug('no private channels found, no need to make request');
|
return;
|
}
|
|
var data = {
|
client: this._clientID,
|
channels: channels
|
};
|
|
var clientID = this._clientID;
|
var xhrID = this._newXHRID();
|
|
var cb = function cb(resp) {
|
if (xhrID in _this19._xhrs) {
|
delete _this19._xhrs[xhrID];
|
}
|
if (_this19._clientID !== clientID) {
|
return;
|
}
|
if (resp.error || resp.status !== 200) {
|
_this19._debug('authorization request failed');
|
for (var i in channels) {
|
if (channels.hasOwnProperty(i)) {
|
var _channel3 = channels[i];
|
_this19._subscribeError(_channel3, _this19._createErrorObject('authorization request failed'));
|
}
|
}
|
return;
|
}
|
|
var channelsData = {};
|
if (resp.data.channels) {
|
for (var _i in resp.data.channels) {
|
var channelData = resp.data.channels[_i];
|
if (!channelData.channel) {
|
continue;
|
}
|
channelsData[channelData.channel] = channelData.token;
|
}
|
}
|
|
// try to send all subscriptions in one request.
|
var batch = false;
|
|
if (!_this19._isBatching) {
|
_this19.startBatching();
|
batch = true;
|
}
|
|
for (var _i2 in channels) {
|
if (channels.hasOwnProperty(_i2)) {
|
var _ret2 = function () {
|
var channel = channels[_i2];
|
var token = channelsData[channel];
|
|
if (!token) {
|
// subscription:error
|
_this19._subscribeError(channel, _this19._createErrorObject('permission denied', 103));
|
return 'continue';
|
} else {
|
var msg = {
|
method: _this19._methodType.SUBSCRIBE,
|
params: {
|
channel: channel,
|
token: token
|
}
|
};
|
|
var _sub2 = _this19._getSub(channel);
|
if (_sub2 === null) {
|
return 'continue';
|
}
|
|
var recover = _sub2._needRecover();
|
|
if (recover === true) {
|
msg.params.recover = true;
|
var seq = _this19._getLastSeq(channel);
|
if (seq) {
|
msg.params.seq = seq;
|
}
|
var gen = _this19._getLastGen(channel);
|
if (gen) {
|
msg.params.gen = gen;
|
}
|
var epoch = _this19._getLastEpoch(channel);
|
if (epoch) {
|
msg.params.epoch = epoch;
|
}
|
}
|
_this19._call(msg).then(function (resolveCtx) {
|
_this19._subscribeResponse(channel, recover, _this19._decoder.decodeCommandResult(_this19._methodType.SUBSCRIBE, resolveCtx.result));
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
_this19._subscribeError(channel, rejectCtx.error);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
}
|
}();
|
|
if (_ret2 === 'continue') continue;
|
}
|
}
|
|
if (batch) {
|
_this19.stopBatching();
|
}
|
};
|
|
if (this._config.onPrivateSubscribe !== null) {
|
this._config.onPrivateSubscribe({
|
data: data
|
}, cb);
|
} else {
|
var xhr = this._ajax(this._config.subscribeEndpoint, this._config.subscribeParams, this._config.subscribeHeaders, data, cb);
|
this._xhrs[xhrID] = xhr;
|
}
|
}
|
}, {
|
key: 'subscribe',
|
value: function subscribe(channel, events) {
|
var currentSub = this._getSub(channel);
|
if (currentSub !== null) {
|
currentSub._setEvents(events);
|
if (currentSub._isUnsubscribed()) {
|
currentSub.subscribe();
|
}
|
return currentSub;
|
}
|
var sub = new _subscription2.default(this, channel, events);
|
this._subs[channel] = sub;
|
sub.subscribe();
|
return sub;
|
}
|
}]);
|
|
return Centrifuge;
|
}(_events2.default);
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
|
|
/***/ }),
|
|
/***/ 11:
|
/***/ (function(module, exports, __webpack_require__) {
|
|
"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 _events = __webpack_require__(6);
|
|
var _events2 = _interopRequireDefault(_events);
|
|
var _utils = __webpack_require__(7);
|
|
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 _STATE_NEW = 0;
|
var _STATE_SUBSCRIBING = 1;
|
var _STATE_SUCCESS = 2;
|
var _STATE_ERROR = 3;
|
var _STATE_UNSUBSCRIBED = 4;
|
|
var Subscription = function (_EventEmitter) {
|
_inherits(Subscription, _EventEmitter);
|
|
function Subscription(centrifuge, channel, events) {
|
_classCallCheck(this, Subscription);
|
|
var _this = _possibleConstructorReturn(this, (Subscription.__proto__ || Object.getPrototypeOf(Subscription)).call(this));
|
|
_this.channel = channel;
|
_this._centrifuge = centrifuge;
|
_this._status = _STATE_NEW;
|
_this._error = null;
|
_this._isResubscribe = false;
|
_this._ready = false;
|
_this._subscriptionPromise = null;
|
_this._noResubscribe = false;
|
_this._recoverable = false;
|
_this._recover = false;
|
_this._setEvents(events);
|
_this._initializePromise();
|
_this._promises = {};
|
_this._promiseId = 0;
|
_this.on('error', function (errContext) {
|
this._centrifuge._debug('subscription error', errContext);
|
});
|
return _this;
|
}
|
|
_createClass(Subscription, [{
|
key: '_nextPromiseId',
|
value: function _nextPromiseId() {
|
return ++this._promiseId;
|
}
|
}, {
|
key: '_initializePromise',
|
value: function _initializePromise() {
|
var _this2 = this;
|
|
// this helps us to wait until subscription will successfully
|
// subscribe and call actions such as presence, history etc in
|
// synchronous way.
|
this._ready = false;
|
|
this._subscriptionPromise = new Promise(function (resolve, reject) {
|
_this2._resolve = function (value) {
|
_this2._ready = true;
|
resolve(value);
|
};
|
_this2._reject = function (err) {
|
_this2._ready = true;
|
reject(err);
|
};
|
}).then(function () {}, function () {});
|
}
|
}, {
|
key: '_needRecover',
|
value: function _needRecover() {
|
return this._recoverable === true && this._recover === true;
|
}
|
}, {
|
key: '_setEvents',
|
value: function _setEvents(events) {
|
if (!events) {
|
return;
|
}
|
if ((0, _utils.isFunction)(events)) {
|
// events is just a function to handle publication received from channel.
|
this.on('publish', events);
|
} else if (Object.prototype.toString.call(events) === Object.prototype.toString.call({})) {
|
var knownEvents = ['publish', 'join', 'leave', 'unsubscribe', 'subscribe', 'error'];
|
for (var i = 0, l = knownEvents.length; i < l; i++) {
|
var ev = knownEvents[i];
|
if (ev in events) {
|
this.on(ev, events[ev]);
|
}
|
}
|
}
|
}
|
}, {
|
key: '_isNew',
|
value: function _isNew() {
|
return this._status === _STATE_NEW;
|
}
|
}, {
|
key: '_isUnsubscribed',
|
value: function _isUnsubscribed() {
|
return this._status === _STATE_UNSUBSCRIBED;
|
}
|
}, {
|
key: '_isSubscribing',
|
value: function _isSubscribing() {
|
return this._status === _STATE_SUBSCRIBING;
|
}
|
}, {
|
key: '_isReady',
|
value: function _isReady() {
|
return this._status === _STATE_SUCCESS || this._status === _STATE_ERROR;
|
}
|
}, {
|
key: '_isSuccess',
|
value: function _isSuccess() {
|
return this._status === _STATE_SUCCESS;
|
}
|
}, {
|
key: '_isError',
|
value: function _isError() {
|
return this._status === _STATE_ERROR;
|
}
|
}, {
|
key: '_setNew',
|
value: function _setNew() {
|
this._status = _STATE_NEW;
|
}
|
}, {
|
key: '_setSubscribing',
|
value: function _setSubscribing(isResubscribe) {
|
this._isResubscribe = isResubscribe || false;
|
if (this._ready === true) {
|
// new promise for this subscription
|
this._initializePromise();
|
}
|
this._status = _STATE_SUBSCRIBING;
|
}
|
}, {
|
key: '_setSubscribeSuccess',
|
value: function _setSubscribeSuccess(recovered) {
|
if (this._status === _STATE_SUCCESS) {
|
return;
|
}
|
this._status = _STATE_SUCCESS;
|
var successContext = this._getSubscribeSuccessContext(recovered);
|
|
this._recover = false;
|
this.emit('subscribe', successContext);
|
this._resolve(successContext);
|
for (var id in this._promises) {
|
clearTimeout(this._promises[id].timeout);
|
this._promises[id].resolve();
|
delete this._promises[id];
|
}
|
}
|
}, {
|
key: '_setSubscribeError',
|
value: function _setSubscribeError(err) {
|
if (this._status === _STATE_ERROR) {
|
return;
|
}
|
this._status = _STATE_ERROR;
|
this._error = err;
|
var errContext = this._getSubscribeErrorContext();
|
this.emit('error', errContext);
|
this._reject(errContext);
|
for (var id in this._promises) {
|
clearTimeout(this._promises[id].timeout);
|
this._promises[id].reject(err);
|
delete this._promises[id];
|
}
|
}
|
}, {
|
key: '_triggerUnsubscribe',
|
value: function _triggerUnsubscribe() {
|
this.emit('unsubscribe', {
|
channel: this.channel
|
});
|
}
|
}, {
|
key: '_setUnsubscribed',
|
value: function _setUnsubscribed(noResubscribe) {
|
this._centrifuge._clearSubRefreshTimeout(this.channel);
|
if (this._status === _STATE_UNSUBSCRIBED) {
|
return;
|
}
|
var needTrigger = this._status === _STATE_SUCCESS;
|
this._status = _STATE_UNSUBSCRIBED;
|
if (noResubscribe === true) {
|
this._recover = false;
|
this._noResubscribe = true;
|
delete this._centrifuge._lastSeq[this.channel];
|
delete this._centrifuge._lastGen[this.channel];
|
delete this._centrifuge._lastEpoch[this.channel];
|
}
|
if (needTrigger) {
|
this._triggerUnsubscribe();
|
}
|
}
|
}, {
|
key: '_shouldResubscribe',
|
value: function _shouldResubscribe() {
|
return !this._noResubscribe;
|
}
|
}, {
|
key: '_getSubscribeSuccessContext',
|
value: function _getSubscribeSuccessContext(recovered) {
|
return {
|
channel: this.channel,
|
isResubscribe: this._isResubscribe,
|
recovered: recovered
|
};
|
}
|
}, {
|
key: '_getSubscribeErrorContext',
|
value: function _getSubscribeErrorContext() {
|
var subscribeErrorContext = this._error;
|
subscribeErrorContext.channel = this.channel;
|
subscribeErrorContext.isResubscribe = this._isResubscribe;
|
return subscribeErrorContext;
|
}
|
}, {
|
key: 'ready',
|
value: function ready(callback, errback) {
|
if (this._ready) {
|
if (this._isSuccess()) {
|
callback(this._getSubscribeSuccessContext());
|
} else {
|
errback(this._getSubscribeErrorContext());
|
}
|
}
|
}
|
}, {
|
key: 'subscribe',
|
value: function subscribe() {
|
if (this._status === _STATE_SUCCESS) {
|
return;
|
}
|
this._noResubscribe = false;
|
this._centrifuge._subscribe(this);
|
}
|
}, {
|
key: 'unsubscribe',
|
value: function unsubscribe() {
|
this._setUnsubscribed(true);
|
this._centrifuge._unsubscribe(this);
|
}
|
}, {
|
key: '_methodCall',
|
value: function _methodCall(message, type) {
|
var _this3 = this;
|
|
var methodCallPromise = new Promise(function (resolve, reject) {
|
var subPromise = void 0;
|
if (_this3._isSuccess()) {
|
subPromise = Promise.resolve();
|
} else if (_this3._isError()) {
|
subPromise = Promise.reject(_this3._error);
|
} else {
|
subPromise = new Promise(function (res, rej) {
|
var timeout = setTimeout(function () {
|
rej({ 'code': 0, 'message': 'timeout' });
|
}, _this3._centrifuge._config.timeout);
|
_this3._promises[_this3._nextPromiseId()] = {
|
timeout: timeout,
|
resolve: res,
|
reject: rej
|
};
|
});
|
}
|
subPromise.then(function () {
|
return _this3._centrifuge._call(message).then(function (resolveCtx) {
|
resolve(_this3._centrifuge._decoder.decodeCommandResult(type, resolveCtx.result));
|
if (resolveCtx.next) {
|
resolveCtx.next();
|
}
|
}, function (rejectCtx) {
|
reject(rejectCtx.error);
|
if (rejectCtx.next) {
|
rejectCtx.next();
|
}
|
});
|
}, function (error) {
|
reject(error);
|
});
|
});
|
return methodCallPromise;
|
}
|
}, {
|
key: 'publish',
|
value: function publish(data) {
|
return this._methodCall({
|
method: this._centrifuge._methodType.PUBLISH,
|
params: {
|
channel: this.channel,
|
data: data
|
}
|
}, this._centrifuge._methodType.PUBLISH);
|
}
|
}, {
|
key: 'presence',
|
value: function presence() {
|
return this._methodCall({
|
method: this._centrifuge._methodType.PRESENCE,
|
params: {
|
channel: this.channel
|
}
|
}, this._centrifuge._methodType.PRESENCE);
|
}
|
}, {
|
key: 'presenceStats',
|
value: function presenceStats() {
|
return this._methodCall({
|
method: this._centrifuge._methodType.PRESENCE_STATS,
|
params: {
|
channel: this.channel
|
}
|
}, this._centrifuge._methodType.PRESENCE_STATS);
|
}
|
}, {
|
key: 'history',
|
value: function history() {
|
return this._methodCall({
|
method: this._centrifuge._methodType.HISTORY,
|
params: {
|
channel: this.channel
|
}
|
}, this._centrifuge._methodType.HISTORY);
|
}
|
}]);
|
|
return Subscription;
|
}(_events2.default);
|
|
exports.default = Subscription;
|
module.exports = exports['default'];
|
|
/***/ }),
|
|
/***/ 12:
|
/***/ (function(module, exports, __webpack_require__) {
|
|
"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; }; }();
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
var JsonMethodType = exports.JsonMethodType = {
|
CONNECT: 0,
|
SUBSCRIBE: 1,
|
UNSUBSCRIBE: 2,
|
PUBLISH: 3,
|
PRESENCE: 4,
|
PRESENCE_STATS: 5,
|
HISTORY: 6,
|
PING: 7,
|
SEND: 8,
|
RPC: 9,
|
REFRESH: 10,
|
SUB_REFRESH: 11
|
};
|
|
var JsonPushType = exports.JsonPushType = {
|
PUBLICATION: 0,
|
JOIN: 1,
|
LEAVE: 2,
|
UNSUB: 3,
|
MESSAGE: 4,
|
SUB: 5
|
};
|
|
var JsonEncoder = exports.JsonEncoder = function () {
|
function JsonEncoder() {
|
_classCallCheck(this, JsonEncoder);
|
}
|
|
_createClass(JsonEncoder, [{
|
key: 'encodeCommands',
|
value: function encodeCommands(commands) {
|
var encodedCommands = [];
|
for (var i in commands) {
|
if (commands.hasOwnProperty(i)) {
|
encodedCommands.push(JSON.stringify(commands[i]));
|
}
|
}
|
return encodedCommands.join('\n');
|
}
|
}]);
|
|
return JsonEncoder;
|
}();
|
|
var JsonDecoder = exports.JsonDecoder = function () {
|
function JsonDecoder() {
|
_classCallCheck(this, JsonDecoder);
|
}
|
|
_createClass(JsonDecoder, [{
|
key: 'decodeReplies',
|
value: function decodeReplies(data) {
|
var replies = [];
|
var encodedReplies = data.split('\n');
|
for (var i in encodedReplies) {
|
if (encodedReplies.hasOwnProperty(i)) {
|
if (!encodedReplies[i]) {
|
continue;
|
}
|
var reply = JSON.parse(encodedReplies[i]);
|
replies.push(reply);
|
}
|
}
|
return replies;
|
}
|
}, {
|
key: 'decodeCommandResult',
|
value: function decodeCommandResult(methodType, data) {
|
return data;
|
}
|
}, {
|
key: 'decodePush',
|
value: function decodePush(data) {
|
return data;
|
}
|
}, {
|
key: 'decodePushData',
|
value: function decodePushData(pushType, data) {
|
return data;
|
}
|
}]);
|
|
return JsonDecoder;
|
}();
|
|
/***/ }),
|
|
/***/ 3:
|
/***/ (function(module, exports) {
|
|
var g;
|
|
// This works in non-strict mode
|
g = (function() {
|
return this;
|
})();
|
|
try {
|
// This works if eval is allowed (see CSP)
|
g = g || Function("return this")() || (1,eval)("this");
|
} catch(e) {
|
// This works if the window reference is available
|
if(typeof window === "object")
|
g = window;
|
}
|
|
// g can still be undefined, but nothing to do about it...
|
// We return undefined, instead of nothing here, so it's
|
// easier to handle this case. if(!global) { ...}
|
|
module.exports = g;
|
|
|
/***/ }),
|
|
/***/ 31:
|
/***/ (function(module, exports, __webpack_require__) {
|
|
"use strict";
|
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
|
var _centrifuge = __webpack_require__(10);
|
|
exports.default = _centrifuge.Centrifuge;
|
module.exports = exports['default'];
|
|
/***/ }),
|
|
/***/ 6:
|
/***/ (function(module, exports, __webpack_require__) {
|
|
"use strict";
|
// Copyright Joyent, Inc. and other Node contributors.
|
//
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
// copy of this software and associated documentation files (the
|
// "Software"), to deal in the Software without restriction, including
|
// without limitation the rights to use, copy, modify, merge, publish,
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
// persons to whom the Software is furnished to do so, subject to the
|
// following conditions:
|
//
|
// The above copyright notice and this permission notice shall be included
|
// in all copies or substantial portions of the Software.
|
//
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
var R = typeof Reflect === 'object' ? Reflect : null
|
var ReflectApply = R && typeof R.apply === 'function'
|
? R.apply
|
: function ReflectApply(target, receiver, args) {
|
return Function.prototype.apply.call(target, receiver, args);
|
}
|
|
var ReflectOwnKeys
|
if (R && typeof R.ownKeys === 'function') {
|
ReflectOwnKeys = R.ownKeys
|
} else if (Object.getOwnPropertySymbols) {
|
ReflectOwnKeys = function ReflectOwnKeys(target) {
|
return Object.getOwnPropertyNames(target)
|
.concat(Object.getOwnPropertySymbols(target));
|
};
|
} else {
|
ReflectOwnKeys = function ReflectOwnKeys(target) {
|
return Object.getOwnPropertyNames(target);
|
};
|
}
|
|
function ProcessEmitWarning(warning) {
|
if (console && console.warn) console.warn(warning);
|
}
|
|
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
|
return value !== value;
|
}
|
|
function EventEmitter() {
|
EventEmitter.init.call(this);
|
}
|
module.exports = EventEmitter;
|
|
// Backwards-compat with node 0.10.x
|
EventEmitter.EventEmitter = EventEmitter;
|
|
EventEmitter.prototype._events = undefined;
|
EventEmitter.prototype._eventsCount = 0;
|
EventEmitter.prototype._maxListeners = undefined;
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
// added to it. This is a useful default which helps finding memory leaks.
|
var defaultMaxListeners = 10;
|
|
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
|
enumerable: true,
|
get: function() {
|
return defaultMaxListeners;
|
},
|
set: function(arg) {
|
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
|
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
|
}
|
defaultMaxListeners = arg;
|
}
|
});
|
|
EventEmitter.init = function() {
|
|
if (this._events === undefined ||
|
this._events === Object.getPrototypeOf(this)._events) {
|
this._events = Object.create(null);
|
this._eventsCount = 0;
|
}
|
|
this._maxListeners = this._maxListeners || undefined;
|
};
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
// that to be increased. Set to zero for unlimited.
|
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
|
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
|
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
|
}
|
this._maxListeners = n;
|
return this;
|
};
|
|
function $getMaxListeners(that) {
|
if (that._maxListeners === undefined)
|
return EventEmitter.defaultMaxListeners;
|
return that._maxListeners;
|
}
|
|
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
|
return $getMaxListeners(this);
|
};
|
|
EventEmitter.prototype.emit = function emit(type) {
|
var args = [];
|
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
|
var doError = (type === 'error');
|
|
var events = this._events;
|
if (events !== undefined)
|
doError = (doError && events.error === undefined);
|
else if (!doError)
|
return false;
|
|
// If there is no 'error' event listener then throw.
|
if (doError) {
|
var er;
|
if (args.length > 0)
|
er = args[0];
|
if (er instanceof Error) {
|
// Note: The comments on the `throw` lines are intentional, they show
|
// up in Node's output if this results in an unhandled exception.
|
throw er; // Unhandled 'error' event
|
}
|
// At least give some kind of context to the user
|
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
|
err.context = er;
|
throw err; // Unhandled 'error' event
|
}
|
|
var handler = events[type];
|
|
if (handler === undefined)
|
return false;
|
|
if (typeof handler === 'function') {
|
ReflectApply(handler, this, args);
|
} else {
|
var len = handler.length;
|
var listeners = arrayClone(handler, len);
|
for (var i = 0; i < len; ++i)
|
ReflectApply(listeners[i], this, args);
|
}
|
|
return true;
|
};
|
|
function _addListener(target, type, listener, prepend) {
|
var m;
|
var events;
|
var existing;
|
|
if (typeof listener !== 'function') {
|
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
|
}
|
|
events = target._events;
|
if (events === undefined) {
|
events = target._events = Object.create(null);
|
target._eventsCount = 0;
|
} else {
|
// To avoid recursion in the case that type === "newListener"! Before
|
// adding it to the listeners, first emit "newListener".
|
if (events.newListener !== undefined) {
|
target.emit('newListener', type,
|
listener.listener ? listener.listener : listener);
|
|
// Re-assign `events` because a newListener handler could have caused the
|
// this._events to be assigned to a new object
|
events = target._events;
|
}
|
existing = events[type];
|
}
|
|
if (existing === undefined) {
|
// Optimize the case of one listener. Don't need the extra array object.
|
existing = events[type] = listener;
|
++target._eventsCount;
|
} else {
|
if (typeof existing === 'function') {
|
// Adding the second element, need to change to array.
|
existing = events[type] =
|
prepend ? [listener, existing] : [existing, listener];
|
// If we've already got an array, just append.
|
} else if (prepend) {
|
existing.unshift(listener);
|
} else {
|
existing.push(listener);
|
}
|
|
// Check for listener leak
|
m = $getMaxListeners(target);
|
if (m > 0 && existing.length > m && !existing.warned) {
|
existing.warned = true;
|
// No error code for this since it is a Warning
|
// eslint-disable-next-line no-restricted-syntax
|
var w = new Error('Possible EventEmitter memory leak detected. ' +
|
existing.length + ' ' + String(type) + ' listeners ' +
|
'added. Use emitter.setMaxListeners() to ' +
|
'increase limit');
|
w.name = 'MaxListenersExceededWarning';
|
w.emitter = target;
|
w.type = type;
|
w.count = existing.length;
|
ProcessEmitWarning(w);
|
}
|
}
|
|
return target;
|
}
|
|
EventEmitter.prototype.addListener = function addListener(type, listener) {
|
return _addListener(this, type, listener, false);
|
};
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
EventEmitter.prototype.prependListener =
|
function prependListener(type, listener) {
|
return _addListener(this, type, listener, true);
|
};
|
|
function onceWrapper() {
|
var args = [];
|
for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
|
if (!this.fired) {
|
this.target.removeListener(this.type, this.wrapFn);
|
this.fired = true;
|
ReflectApply(this.listener, this.target, args);
|
}
|
}
|
|
function _onceWrap(target, type, listener) {
|
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
|
var wrapped = onceWrapper.bind(state);
|
wrapped.listener = listener;
|
state.wrapFn = wrapped;
|
return wrapped;
|
}
|
|
EventEmitter.prototype.once = function once(type, listener) {
|
if (typeof listener !== 'function') {
|
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
|
}
|
this.on(type, _onceWrap(this, type, listener));
|
return this;
|
};
|
|
EventEmitter.prototype.prependOnceListener =
|
function prependOnceListener(type, listener) {
|
if (typeof listener !== 'function') {
|
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
|
}
|
this.prependListener(type, _onceWrap(this, type, listener));
|
return this;
|
};
|
|
// Emits a 'removeListener' event if and only if the listener was removed.
|
EventEmitter.prototype.removeListener =
|
function removeListener(type, listener) {
|
var list, events, position, i, originalListener;
|
|
if (typeof listener !== 'function') {
|
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
|
}
|
|
events = this._events;
|
if (events === undefined)
|
return this;
|
|
list = events[type];
|
if (list === undefined)
|
return this;
|
|
if (list === listener || list.listener === listener) {
|
if (--this._eventsCount === 0)
|
this._events = Object.create(null);
|
else {
|
delete events[type];
|
if (events.removeListener)
|
this.emit('removeListener', type, list.listener || listener);
|
}
|
} else if (typeof list !== 'function') {
|
position = -1;
|
|
for (i = list.length - 1; i >= 0; i--) {
|
if (list[i] === listener || list[i].listener === listener) {
|
originalListener = list[i].listener;
|
position = i;
|
break;
|
}
|
}
|
|
if (position < 0)
|
return this;
|
|
if (position === 0)
|
list.shift();
|
else {
|
spliceOne(list, position);
|
}
|
|
if (list.length === 1)
|
events[type] = list[0];
|
|
if (events.removeListener !== undefined)
|
this.emit('removeListener', type, originalListener || listener);
|
}
|
|
return this;
|
};
|
|
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
|
|
EventEmitter.prototype.removeAllListeners =
|
function removeAllListeners(type) {
|
var listeners, events, i;
|
|
events = this._events;
|
if (events === undefined)
|
return this;
|
|
// not listening for removeListener, no need to emit
|
if (events.removeListener === undefined) {
|
if (arguments.length === 0) {
|
this._events = Object.create(null);
|
this._eventsCount = 0;
|
} else if (events[type] !== undefined) {
|
if (--this._eventsCount === 0)
|
this._events = Object.create(null);
|
else
|
delete events[type];
|
}
|
return this;
|
}
|
|
// emit removeListener for all listeners on all events
|
if (arguments.length === 0) {
|
var keys = Object.keys(events);
|
var key;
|
for (i = 0; i < keys.length; ++i) {
|
key = keys[i];
|
if (key === 'removeListener') continue;
|
this.removeAllListeners(key);
|
}
|
this.removeAllListeners('removeListener');
|
this._events = Object.create(null);
|
this._eventsCount = 0;
|
return this;
|
}
|
|
listeners = events[type];
|
|
if (typeof listeners === 'function') {
|
this.removeListener(type, listeners);
|
} else if (listeners !== undefined) {
|
// LIFO order
|
for (i = listeners.length - 1; i >= 0; i--) {
|
this.removeListener(type, listeners[i]);
|
}
|
}
|
|
return this;
|
};
|
|
function _listeners(target, type, unwrap) {
|
var events = target._events;
|
|
if (events === undefined)
|
return [];
|
|
var evlistener = events[type];
|
if (evlistener === undefined)
|
return [];
|
|
if (typeof evlistener === 'function')
|
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
|
|
return unwrap ?
|
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
|
}
|
|
EventEmitter.prototype.listeners = function listeners(type) {
|
return _listeners(this, type, true);
|
};
|
|
EventEmitter.prototype.rawListeners = function rawListeners(type) {
|
return _listeners(this, type, false);
|
};
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
if (typeof emitter.listenerCount === 'function') {
|
return emitter.listenerCount(type);
|
} else {
|
return listenerCount.call(emitter, type);
|
}
|
};
|
|
EventEmitter.prototype.listenerCount = listenerCount;
|
function listenerCount(type) {
|
var events = this._events;
|
|
if (events !== undefined) {
|
var evlistener = events[type];
|
|
if (typeof evlistener === 'function') {
|
return 1;
|
} else if (evlistener !== undefined) {
|
return evlistener.length;
|
}
|
}
|
|
return 0;
|
}
|
|
EventEmitter.prototype.eventNames = function eventNames() {
|
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
|
};
|
|
function arrayClone(arr, n) {
|
var copy = new Array(n);
|
for (var i = 0; i < n; ++i)
|
copy[i] = arr[i];
|
return copy;
|
}
|
|
function spliceOne(list, index) {
|
for (; index + 1 < list.length; index++)
|
list[index] = list[index + 1];
|
list.pop();
|
}
|
|
function unwrapListeners(arr) {
|
var ret = new Array(arr.length);
|
for (var i = 0; i < ret.length; ++i) {
|
ret[i] = arr[i].listener || arr[i];
|
}
|
return ret;
|
}
|
|
|
/***/ }),
|
|
/***/ 7:
|
/***/ (function(module, exports, __webpack_require__) {
|
|
"use strict";
|
/* WEBPACK VAR INJECTION */(function(global) {
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.startsWith = startsWith;
|
exports.isFunction = isFunction;
|
exports.log = log;
|
exports.backoff = backoff;
|
exports.errorExists = errorExists;
|
exports.extend = extend;
|
function startsWith(value, prefix) {
|
return value.lastIndexOf(prefix, 0) === 0;
|
};
|
|
function isFunction(value) {
|
if (value === undefined || value === null) {
|
return false;
|
}
|
return typeof value === 'function';
|
};
|
|
function log(level, args) {
|
if (global.console) {
|
var logger = global.console[level];
|
|
if (isFunction(logger)) {
|
logger.apply(global.console, args);
|
}
|
}
|
};
|
|
function backoff(step, min, max) {
|
var jitter = 0.5 * Math.random();
|
var interval = Math.min(max, min * Math.pow(2, step + 1));
|
|
return Math.floor((1 - jitter) * interval);
|
};
|
|
function errorExists(data) {
|
return 'error' in data && data.error !== null;
|
};
|
|
function extend(a, b) {
|
for (var key in b) {
|
if (b.hasOwnProperty(key)) {
|
a[key] = b[key];
|
}
|
}
|
return a;
|
};
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
|
|
/***/ })
|
|
/******/ });
|
});
|
//# sourceMappingURL=centrifuge.js.map
|
