hooksi/dist/index.js

Lightweight events hooking module

"use strict";
var __spreadArray = (this && this.__spreadArray) || function (to, from) {
    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
        to[j] = from[i];
    return to;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Hooks = void 0;
var Hooks = /** @class */ (function () {
    function Hooks() {
        this._hooksMap = new Map();
    }
    /**
     * Subscribe to a hook
     *
     * Can have as many callbacks as you want!
     *
     * The order of execution is the order of subscription
     *
     * @template HookName
     * @param {HookName} hookName
     * @param {HooksDefinition[HookName]} callback
     * @returns {this}
     * @memberof Hooks
     */
    Hooks.prototype.on = function (hookName, callback) {
        if (!this._hooksMap.has(hookName)) {
            this._hooksMap.set(hookName, []);
        }
        this._hooksMap.get(hookName).push(callback);
        return this;
    };
    /**
     * Unsubscribe a callback by it's ref
     *
     * Return true if found and removed! False if it wasn't found
     *
     * @template HookName
     * @param {HookName} hookName
     * @param {HooksDefinition[HookName]} callback
     * @returns {boolean} true if removed! false if not found!
     * @memberof Hooks
     */
    Hooks.prototype.unsubscribe = function (hookName, callback) {
        var hookList = this._hooksMap.get(hookName);
        if (hookList && hookList.length > 0) {
            var callbackIndex = hookList.indexOf(callback);
            if (callbackIndex > -1) {
                hookList.splice(callbackIndex, 1);
                if (hookList.length === 0) {
                    this.unsubscribeAll(hookName);
                }
                return true;
            }
        }
        return false;
    };
    /**
     * Unsubscribe all callbacks for a hook
     *
     * return true if callbacks where unsubscribed! False if none were already subscribed!
     *
     * @template HookName
     * @param {HookName} hookName
     * @returns {boolean} true if callbacks where unsubscribed! False if none were already subscribed!
     * @memberof Hooks
     */
    Hooks.prototype.unsubscribeAll = function (hookName) {
        return this._hooksMap.delete(hookName);
    };
    /**
     * Synchronous Hook execution in code
     *
     * (That can be too the event emitter)
     *
     * @template HookName
     * @param {HookName} hookName
     * @param {*} _this this Context in the subscribing callbacks
     * @param {...Parameters<HooksDefinition[HookName]>} args call params (callback passed params)
     * @returns {this}
     * @memberof Hooks
     */
    Hooks.prototype.exec = function (hookName, _this) {
        var _a;
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        var hookCallbacks = this._hooksMap.get(hookName);
        if (hookCallbacks) {
            for (var i = 0; i < hookCallbacks.length; i++) {
                (_a = hookCallbacks[i]).call.apply(_a, __spreadArray([_this], args));
            }
        }
        return this;
    };
    /**
     * Alias for exec
     *
     * Emit name alias
     *
     * May be preferred for readability when using the event emitter pattern
     *
     * @template HookName
     * @param {HookName} hookName
     * @param {*} _this this Context in the subscribing callbacks
     * @param {...Parameters<HooksDefinition[HookName]>} args call params (callback passed params)
     * @returns {this}
     * @memberof Hooks
     */
    Hooks.prototype.emit = function (hookName, _this) {
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        return this.exec.apply(this, __spreadArray([hookName, _this], args));
    };
    /**
     * Asynchronous Hook execution in code
     *
     * (That can be too the event emitter)
     *
     * @template HookName
     * @param {HookName} hookName
     * @param {*} _this this Context in the subscribing callbacks
     * @param {...Parameters<HooksDefinition[HookName]>} args call params (callback passed params)
     * @returns {Promise<any>[]}
     * @memberof Hooks
     */
    Hooks.prototype.execAsync = function (hookName, _this) {
        var _a;
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        var hookCallbacks = this._hooksMap.get(hookName);
        var promises = [];
        if (hookCallbacks) {
            for (var i = 0; i < hookCallbacks.length; i++) {
                promises.push(Promise.resolve((_a = hookCallbacks[i]).call.apply(_a, __spreadArray([_this], args))));
            }
        }
        return promises;
    };
    /**
     * Alias to execAsync
     *
     * Emit name alias
     *
     * @template HookName
     * @param {HookName} hookName
     * @param {*} _this this Context in the subscribing callbacks
     * @param {...Parameters<HooksDefinition[HookName]>} args call params (callback passed params)
     * @returns {Promise<any>[]}
     * @memberof Hooks
     */
    Hooks.prototype.emitAsync = function (hookName, _this) {
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        return this.execAsync.apply(this, __spreadArray([hookName, _this], args));
    };
    /**
     * Check if there is a subscriber for a hook
     *
     * @template HookName
     * @param {HookName} hookName
     * @returns {boolean}
     * @memberof Hooks
     */
    Hooks.prototype.hasSubscriber = function (hookName) {
        var callbacks = this._hooksMap.get(hookName);
        if (callbacks && callbacks.length > 0) {
            return true;
        }
        return false;
    };
    /**
     * Get the list of the hook callbacks
     *
     * @template HookName
     * @param {HookName} hookName
     * @returns {(HooksDefinition[HookName][] | undefined)}
     * @memberof Hooks
     */
    Hooks.prototype.getHookCallbacks = function (hookName) {
        return this._hooksMap.get(hookName);
    };
    /**
     * Get the hooks map
     *
     * @returns {THooksMap<HooksDefinition>}
     * @memberof Hooks
     */
    Hooks.prototype.getHooksMap = function () {
        return this._hooksMap;
    };
    return Hooks;
}());
exports.Hooks = Hooks;