event-handler-manager/lib/EventHandlerManager.ts

A typescript (also javascript) simple Event Handler Manager

import { IEventHandlerManager } from './IEventHandlerManager';
import * as Q from 'q';

export class EventHandlerManager implements IEventHandlerManager {
  
  private eventsRefs : any;
  private events: any;
  private idCounter : number;

  constructor() {
    this.events = {};
    this.eventsRefs = {};
    this.idCounter = 0;
  }

  attach(events: string[]);
  attach(event: string);
  attach(events: string[] | string) {
    
    if (events instanceof Array) {
      events.forEach(event => {
        this.events[event] = [];
      });
    } else {
      this.events[events] = [];
    }
  }

  on(event: string, action: Function): number;
  on(events: string[], action: Function): number[];
  on(events: string | string[], action: Function): any {
    let eventsList = [];
    if (!(events instanceof Array)) {
      eventsList.push(events);
    } else {
      eventsList = events;
    }
    let eventIdList = [];
    eventsList.forEach(event => {
      const currentEvent = {
        eventId: ++this.idCounter,
        action: (event, sender) => {
          return Q.spread([event, sender],
            (event, sender) => action(event, sender));
        }
      }
      this.events[event].push(currentEvent);
      eventIdList.push(currentEvent.eventId);
      this.eventsRefs[currentEvent.eventId] = currentEvent;
    });
    if (eventIdList.length === 1) {
      return eventIdList[0];
    }
    return eventIdList;
  }
 
  off(eventRef: number): void;
  off(event: string): void;
  off(): void;
  off(eventRef?: number | string): void {
    if (typeof eventRef === "number") {
      this.eventsRefs[eventRef] = null;
      let currentEvent = this.events.find(event => {
        return event.eventId === eventRef;
      });
      if (currentEvent !== undefined && currentEvent !== null) {
        currentEvent = null;
      }
    } else if (typeof eventRef === "string") {
      this.events[eventRef].forEach(event => {
        this.eventsRefs[event.eventId] = null;
      });
      this.events[eventRef] = null;
      
    } else if (eventRef === undefined || eventRef === null) {
      this.events = {};
      this.eventsRefs = {};
    }
  }

  trigger(event: string, sequential?: boolean, order?: string): Promise<any>;
  trigger(events: string[], sequential?: boolean, order?: string): Promise<any>;
  trigger(events: string | string[], sequential?: boolean, order?: string): Promise<any> {
    let eventsList = [];
    if (!(events instanceof Array)) {
      eventsList.push(events);
    } else {
      eventsList = events;
    }
    let executionQueue = [];

    eventsList.forEach(eventParam => {
      this.events[eventParam].forEach(event => {
        executionQueue.push(() => {

          return event.action(eventParam, this);
            

        });
      });
    });

    if (sequential) {
      if (order === 'reverse') {
        return executionQueue.slice().reverse().reduce(Q.when, Q());
      }
      return executionQueue.reduce(Q.when, Q());
    }
    let asyncQueue = [];
    executionQueue.forEach(callback => {
      asyncQueue.push(callback());
    });
    return Q.all(asyncQueue);

  }

}