Support events with 2 args

This will allow higher perf events by avoiding object creation

src/common/EventEmitter.ts

@@ -5,28 +5,28 @@
 
 import { IDisposable } from 'common/Types';
 
-interface IListener<T> {
-  (e: T): void;
+interface IListener<T, U = void> {
+  (arg1: T, arg2: U): void;
 }
 
-export interface IEvent<T> {
-  (listener: (e: T) => any): IDisposable;
+export interface IEvent<T, U = void> {
+  (listener: (arg1: T, arg2: U) => any): IDisposable;
 }
 
-export interface IEventEmitter<T> {
-  event: IEvent<T>;
-  fire(data: T): void;
+export interface IEventEmitter<T, U = void> {
+  event: IEvent<T, U>;
+  fire(arg1: T, arg2: U): void;
   dispose(): void;
 }
 
-export class EventEmitter<T> implements IEventEmitter<T> {
-  private _listeners: IListener<T>[] = [];
-  private _event?: IEvent<T>;
+export class EventEmitter<T, U = void> implements IEventEmitter<T, U> {
+  private _listeners: IListener<T, U>[] = [];
+  private _event?: IEvent<T, U>;
   private _disposed: boolean = false;
 
-  public get event(): IEvent<T> {
+  public get event(): IEvent<T, U> {
     if (!this._event) {
-      this._event = (listener: (e: T) => any) => {
+      this._event = (listener: (arg1: T, arg2: U) => any) => {
         this._listeners.push(listener);
         const disposable = {
           dispose: () => {
@@ -46,13 +46,13 @@ export class EventEmitter<T> implements IEventEmitter<T> {
     return this._event;
   }
 
-  public fire(data: T): void {
-    const queue: IListener<T>[] = [];
+  public fire(arg1: T, arg2: U): void {
+    const queue: IListener<T, U>[] = [];
     for (let i = 0; i < this._listeners.length; i++) {
       queue.push(this._listeners[i]);
     }
     for (let i = 0; i < queue.length; i++) {
-      queue[i].call(undefined, data);
+      queue[i].call(undefined, arg1, arg2);
     }
   }