class-event-handler
Version:
A Generic Event Handler
176 lines (175 loc) • 6.61 kB
JavaScript
;
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventHandler = void 0;
/**
* Class for implementing callback events
*/
var EventHandler = /** @class */ (function () {
function EventHandler() {
this.listeners = new Map();
this.onceListeners = new Map();
this.triggerdLabels = new Map();
}
/**
* Helper-function for onReady and onceReady
* the callbackfunction will execute,
* if the label has already been triggerd with the last called parameters
*
* @param label lebel of callback
* @param callback callback function
*/
EventHandler.prototype.wasCalled = function (label, callback) {
if (this.triggerdLabels.has(label)) {
var args = this.triggerdLabels.get(label);
if (args) {
callback.apply(void 0, args);
}
else {
callback();
}
return true;
}
else {
return false;
}
};
/**
* Execute the callback everytime the label is trigger
* @param label label of callback
* @param callback callback function
* @param checkPast check if the label had been already called
* and if so excute the callback immediately with the same
* parameters as last callback; default: `false`
*/
EventHandler.prototype.on = function (label, callback, checkPast) {
if (checkPast === void 0) { checkPast = false; }
if (!this.listeners.has(label))
this.listeners.set(label, []);
var fnArray = this.listeners.get(label);
if (fnArray) {
fnArray.push(callback);
}
if (checkPast)
this.wasCalled(label, callback);
};
/**
* Execute the callback everytime the label is triggered
* check if the label had been already called
* and if so excute the callback immediately with the same parameters for last callback
*
* @param label label of callback
* @param callback callback function
*/
EventHandler.prototype.onReady = function (label, callback) {
this.on(label, callback, true);
};
/**
*
* @param label label of callback
* @param callback callback function
* @param checkPast check if the label had been already called
* and if so excute the callback immediately; default: `false`
*/
EventHandler.prototype.once = function (label, callback, checkPast) {
var _this = this;
if (checkPast === void 0) { checkPast = false; }
if (!this.onceListeners.has(label))
this.onceListeners.set(label, []);
var doPushOnOnceListeners = function () {
var result = true;
if (checkPast && _this.wasCalled(label, callback)) {
result = false;
}
return result;
};
// if (!(checkPast && this.wasCalled(label, callback))) {
if (doPushOnOnceListeners()) {
var fnArray = this.onceListeners.get(label);
if (fnArray) {
fnArray.push(callback);
}
}
};
/**
* Execute the callback onetime when the label is triggered
* or execute the callback if the label had been called already
* @param label Label of callback
* @param callback Callback function
*/
EventHandler.prototype.onceReady = function (label, callback) {
this.once(label, callback, true);
};
/**
* Remove the callback for a label or for a single callback
* @param label Label of callback
* @param callback Callback function or boolean
* @summary If callback is a function then only that functions is removed from callbacks;
* Otherwise, all callbacks will be removed when callback parameter = `true`
*/
EventHandler.prototype.off = function (label, callback) {
if (callback === void 0) { callback = true; }
if (typeof callback === 'boolean' && callback === true) {
// remove listeners for all callbackfunctions
this.listeners.delete(label);
this.onceListeners.delete(label);
}
else if (typeof callback === 'function') {
// remove listeners only with match callbackfunctions
var offCallbackFn = function (inListener) {
var listeners = inListener.get(label);
if (listeners) {
inListener.set(label, listeners.filter(function (value) { return !(value === callback); }));
}
};
offCallbackFn(this.listeners);
offCallbackFn(this.onceListeners);
}
};
/**
* Remove all event listeners
* @param label label of callback(s)
*/
EventHandler.prototype.removeAllEventListeners = function (label) {
this.off(label, true);
};
/**
* Trigger the event with the label
* @param label Label of callback
* @param args arggs to pass to callback
* @returns `true` if a callback was called; Otherwise, `false`
*/
EventHandler.prototype.trigger = function (label) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var res = false;
this.triggerdLabels.set(label, __spreadArrays(args)); // save all triggerd labels for onready and onceready
var trig = function (inListener, trigLabel) {
var trigArgs = [];
for (var _i = 2; _i < arguments.length; _i++) {
trigArgs[_i - 2] = arguments[_i];
}
var listeners = inListener.get(trigLabel);
if (listeners && listeners.length) {
listeners.forEach(function (listener) {
listener.apply(void 0, trigArgs);
});
res = true;
}
};
trig.apply(void 0, __spreadArrays([this.onceListeners, label], args));
trig.apply(void 0, __spreadArrays([this.listeners, label], args));
this.onceListeners.delete(label); // callback for once executed, so delete it.
return res;
};
return EventHandler;
}());
exports.EventHandler = EventHandler;