alm
Version:
The best IDE for TypeScript
259 lines (258 loc) • 9.61 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var EmitterEvent = /** @class */ (function () {
function EmitterEvent(eventType, data) {
if (eventType === void 0) { eventType = null; }
if (data === void 0) { data = null; }
this._type = eventType;
this._data = data;
}
EmitterEvent.prototype.getType = function () {
return this._type;
};
EmitterEvent.prototype.getData = function () {
return this._data;
};
return EmitterEvent;
}());
exports.EmitterEvent = EmitterEvent;
var EventEmitter = /** @class */ (function () {
function EventEmitter(allowedEventTypes) {
if (allowedEventTypes === void 0) { allowedEventTypes = null; }
this._listeners = {};
this._bulkListeners = [];
this._collectedEvents = [];
this._deferredCnt = 0;
if (allowedEventTypes) {
this._allowedEventTypes = {};
for (var i = 0; i < allowedEventTypes.length; i++) {
this._allowedEventTypes[allowedEventTypes[i]] = true;
}
}
else {
this._allowedEventTypes = null;
}
}
EventEmitter.prototype.dispose = function () {
this._listeners = {};
this._bulkListeners = [];
this._collectedEvents = [];
this._deferredCnt = 0;
this._allowedEventTypes = null;
};
EventEmitter.prototype.addListener = function (eventType, listener) {
if (eventType === '*') {
throw new Error('Use addBulkListener(listener) to register your listener!');
}
if (this._allowedEventTypes && !this._allowedEventTypes.hasOwnProperty(eventType)) {
throw new Error('This object will never emit this event type!');
}
if (this._listeners.hasOwnProperty(eventType)) {
this._listeners[eventType].push(listener);
}
else {
this._listeners[eventType] = [listener];
}
var bound = this;
return {
dispose: function () {
if (!bound) {
// Already called
return;
}
bound._removeListener(eventType, listener);
// Prevent leakers from holding on to the event emitter
bound = null;
listener = null;
}
};
};
EventEmitter.prototype.addListener2 = function (eventType, listener) {
return this.addListener(eventType, listener);
};
EventEmitter.prototype.addOneTimeListener = function (eventType, listener) {
var unbind = this.addListener(eventType, function (value) {
unbind.dispose();
listener(value);
});
return unbind;
};
EventEmitter.prototype.addOneTimeDisposableListener = function (eventType, listener) {
return this.addOneTimeListener(eventType, listener);
};
EventEmitter.prototype.addBulkListener = function (listener) {
var _this = this;
this._bulkListeners.push(listener);
return {
dispose: function () {
_this._removeBulkListener(listener);
}
};
};
EventEmitter.prototype.addBulkListener2 = function (listener) {
return this.addBulkListener(listener);
};
EventEmitter.prototype.addEmitter = function (eventEmitter) {
var _this = this;
return eventEmitter.addBulkListener2(function (events) {
var newEvents = events;
if (_this._deferredCnt === 0) {
_this._emitEvents(newEvents);
}
else {
// Collect for later
_this._collectedEvents.push.apply(_this._collectedEvents, newEvents);
}
});
};
EventEmitter.prototype.addEmitter2 = function (eventEmitter) {
return this.addEmitter(eventEmitter);
};
EventEmitter.prototype._removeListener = function (eventType, listener) {
if (this._listeners.hasOwnProperty(eventType)) {
var listeners = this._listeners[eventType];
for (var i = 0, len = listeners.length; i < len; i++) {
if (listeners[i] === listener) {
listeners.splice(i, 1);
break;
}
}
}
};
EventEmitter.prototype._removeBulkListener = function (listener) {
for (var i = 0, len = this._bulkListeners.length; i < len; i++) {
if (this._bulkListeners[i] === listener) {
this._bulkListeners.splice(i, 1);
break;
}
}
};
EventEmitter.prototype._emitToSpecificTypeListeners = function (eventType, data) {
if (this._listeners.hasOwnProperty(eventType)) {
var listeners = this._listeners[eventType].slice(0);
for (var i = 0, len = listeners.length; i < len; i++) {
safeInvoke1Arg(listeners[i], data);
}
}
};
EventEmitter.prototype._emitToBulkListeners = function (events) {
var bulkListeners = this._bulkListeners.slice(0);
for (var i = 0, len = bulkListeners.length; i < len; i++) {
safeInvoke1Arg(bulkListeners[i], events);
}
};
EventEmitter.prototype._emitEvents = function (events) {
if (this._bulkListeners.length > 0) {
this._emitToBulkListeners(events);
}
for (var i = 0, len = events.length; i < len; i++) {
var e = events[i];
this._emitToSpecificTypeListeners(e.getType(), e.getData());
}
};
EventEmitter.prototype.emit = function (eventType, data) {
if (data === void 0) { data = {}; }
if (this._allowedEventTypes && !this._allowedEventTypes.hasOwnProperty(eventType)) {
throw new Error('Cannot emit this event type because it wasn\'t white-listed!');
}
// Early return if no listeners would get this
if (!this._listeners.hasOwnProperty(eventType) && this._bulkListeners.length === 0) {
return;
}
var emitterEvent = new EmitterEvent(eventType, data);
if (this._deferredCnt === 0) {
this._emitEvents([emitterEvent]);
}
else {
// Collect for later
this._collectedEvents.push(emitterEvent);
}
};
EventEmitter.prototype.deferredEmit = function (callback) {
this._deferredCnt = this._deferredCnt + 1;
var result = safeInvokeNoArg(callback);
this._deferredCnt = this._deferredCnt - 1;
if (this._deferredCnt === 0) {
this._emitCollected();
}
return result;
};
EventEmitter.prototype._emitCollected = function () {
// Flush collected events
var events = this._collectedEvents;
this._collectedEvents = [];
if (events.length > 0) {
this._emitEvents(events);
}
};
return EventEmitter;
}());
exports.EventEmitter = EventEmitter;
var EmitQueueElement = /** @class */ (function () {
function EmitQueueElement(target, arg) {
this.target = target;
this.arg = arg;
}
return EmitQueueElement;
}());
/**
* Same as EventEmitter, but guarantees events are delivered in order to each listener
*/
var OrderGuaranteeEventEmitter = /** @class */ (function (_super) {
__extends(OrderGuaranteeEventEmitter, _super);
function OrderGuaranteeEventEmitter(allowedEventTypes) {
if (allowedEventTypes === void 0) { allowedEventTypes = null; }
var _this = _super.call(this, allowedEventTypes) || this;
_this._emitQueue = [];
return _this;
}
OrderGuaranteeEventEmitter.prototype._emitToSpecificTypeListeners = function (eventType, data) {
if (this._listeners.hasOwnProperty(eventType)) {
var listeners = this._listeners[eventType];
for (var i = 0, len = listeners.length; i < len; i++) {
this._emitQueue.push(new EmitQueueElement(listeners[i], data));
}
}
};
OrderGuaranteeEventEmitter.prototype._emitToBulkListeners = function (events) {
var bulkListeners = this._bulkListeners;
for (var i = 0, len = bulkListeners.length; i < len; i++) {
this._emitQueue.push(new EmitQueueElement(bulkListeners[i], events));
}
};
OrderGuaranteeEventEmitter.prototype._emitEvents = function (events) {
_super.prototype._emitEvents.call(this, events);
while (this._emitQueue.length > 0) {
var queueElement = this._emitQueue.shift();
safeInvoke1Arg(queueElement.target, queueElement.arg);
}
};
return OrderGuaranteeEventEmitter;
}(EventEmitter));
exports.OrderGuaranteeEventEmitter = OrderGuaranteeEventEmitter;
function safeInvokeNoArg(func) {
try {
return func();
}
catch (e) {
console.error(e);
}
}
function safeInvoke1Arg(func, arg1) {
try {
return func(arg1);
}
catch (e) {
console.error(e);
}
}