danholibraryjs 1.11.0 → 2.0.1

package/src/Classes/Events/EventCollection.ts

@@ -7,103 +7,103 @@ import Event from './Event';
  * @borrows Event
  * @borrows BaseEvent
  */
- export class EventCollection<Events extends BaseEvent<string, Array<any>>> {
-    constructor(events?: Map<keyof Events, EventHandler<Events>>) {
-        this._events = !events ? 
-            new Map<keyof Events, Event<Events>>() : 
-            events.array().reduce((result, [event, handlers]) => 
-                result.set(event, new Event<Events>(event, handlers)), 
-            new Map<keyof Events, Event<Events>>());
-    }
+export class EventCollection<Events extends BaseEvent<string, Array<any>>> {
+  constructor(events?: Map<keyof Events, EventHandler<Events>>) {
+    this._events = !events ?
+      new Map<keyof Events, Event<Events>>() :
+      events.array().reduce((result, [event, handlers]) =>
+        result.set(event, new Event<Events>(event, handlers)),
+        new Map<keyof Events, Event<Events>>());
+  }
 
-    /**Amount of events stored*/
-    public get size() {
-        return this._events.size;
-    }
-    /**@private Internal event collection*/
-    private _events = new Map<keyof Events, Event<Events>>();
-    /**@private limit of events*/
-    private _limit = 0;
-    
-    /**
-     * Returns true if event is in collection
-     * @param event Event name
-     * @returns true if event is in collection
-     */
-    public has<EventName extends keyof Events>(event: EventName): boolean { 
-        return this._events.has(event); 
-    }
-    /**
-     * Returns event matching event parameter
-     * @param event Event name
-     * @returns Event
-     */
-    public get<EventName extends keyof Events>(event: EventName): Event<Events, EventName> { 
-        return this._events.get(event) as any; 
-    }
-    /**
-     * Adds handler to event collection with name as key
-     * @param name Event name
-     * @param handler Handler for event
-     * @returns this
-     */
-    public add<EventName extends keyof Events>(name: EventName, handler: EventHandler<Events, keyof Events>, once = false): this {
-        if (this._limit > 0 && this._limit + 1 > this._events.size) {
-            throw new Error(`Listener limit, ${this._limit}, reached!`);
-        }
+  /**Amount of events stored*/
+  public get size() {
+    return this._events.size;
+  }
+  /**@private Internal event collection*/
+  private _events = new Map<keyof Events, Event<Events>>();
+  /**@private limit of events*/
+  private _limit = 0;
 
-        const event = (this.has(name) && this.get(name)) || new Event(name);
-        this._events.set(name, event.on(handler, once) as any); 
-        return this;
+  /**
+   * Returns true if event is in collection
+   * @param event Event name
+   * @returns true if event is in collection
+   */
+  public has<EventName extends keyof Events>(event: EventName): boolean {
+    return this._events.has(event);
+  }
+  /**
+   * Returns event matching event parameter
+   * @param event Event name
+   * @returns Event
+   */
+  public get<EventName extends keyof Events>(event: EventName): Event<Events, EventName> {
+    return this._events.get(event) as any;
+  }
+  /**
+   * Adds handler to event collection with name as key
+   * @param name Event name
+   * @param handler Handler for event
+   * @returns this
+   */
+  public add<EventName extends keyof Events>(name: EventName, handler: EventHandler<Events, keyof Events>, once = false): this {
+    if (this._limit > 0 && this._limit + 1 > this._events.size) {
+      throw new Error(`Listener limit, ${this._limit}, reached!`);
     }
-    /**
-     * @summary clear(): Clears all events
-     * @summary clear("all", myEventHandler): Removes myEventHandler from all events that have it
-     * @summary clear("myEvent"): Clears all handlers tied to "myEvent"
-     * @summary clear("myEvent", myEventHandler): Removes myEventHandler from "myEvent"
-     * 
-     * @param name Event name | "all"
-     * @param handler Specific handler to remove. If left blank, all handlers in name will be removed
-     * @returns this
-     */
-    public clear<EventName extends keyof Events>(name: EventName | 'all' = 'all', handler?: EventHandler): this {
-        const _name = name as string;
 
-        if (_name.toLowerCase() == 'all' && handler == null) this._events.clear();                                      //clear(): Clears all events
-        else if (_name.toLowerCase() == 'all' && handler) this._events = (() => {                                       //clear("all", myEventHandler): Removes the "myEventHandler" handler from all events
-            this._events.forEach(e => e.off(handler))
-            return this._events;
-        })();
-        else if (_name.toLowerCase() != "all" && handler == null) this._events.delete(name);                            //clear("myEvent"): Clears All handlers tied to "myEvent"
-        else if (_name.toLowerCase() != 'all' && handler) this._events.set(name, this._events.get(name)!.off(handler));  //clear("myEvent", myEventHandler): Removes the "myEventsHandler" handler from "myEvent"
-        return this;
-    }
+    const event = (this.has(name) && this.get(name)) || new Event(name);
+    this._events.set(name, event.on(handler, once) as any);
+    return this;
+  }
+  /**
+   * @summary clear(): Clears all events
+   * @summary clear("all", myEventHandler): Removes myEventHandler from all events that have it
+   * @summary clear("myEvent"): Clears all handlers tied to "myEvent"
+   * @summary clear("myEvent", myEventHandler): Removes myEventHandler from "myEvent"
+   * 
+   * @param name Event name | "all"
+   * @param handler Specific handler to remove. If left blank, all handlers in name will be removed
+   * @returns this
+   */
+  public clear<EventName extends keyof Events>(name: EventName | 'all' = 'all', handler?: EventHandler): this {
+    const _name = name as string;
 
-    public emit<Event extends keyof Events>(name: Event, ...args: Events[Event]) {
-        return this.get(name)?.emit(...args);
-    }
+    if (_name.toLowerCase() == 'all' && handler == null) this._events.clear();                                      //clear(): Clears all events
+    else if (_name.toLowerCase() == 'all' && handler) this._events = (() => {                                       //clear("all", myEventHandler): Removes the "myEventHandler" handler from all events
+      this._events.forEach(e => e.off(handler));
+      return this._events;
+    })();
+    else if (_name.toLowerCase() != "all" && handler == null) this._events.delete(name);                            //clear("myEvent"): Clears All handlers tied to "myEvent"
+    else if (_name.toLowerCase() != 'all' && handler) this._events.set(name, this._events.get(name)!.off(handler));  //clear("myEvent", myEventHandler): Removes the "myEventsHandler" handler from "myEvent"
+    return this;
+  }
+
+  public emit<Event extends keyof Events>(name: Event, ...args: Events[Event]) {
+    return this.get(name)?.emit(...args);
+  }
 
-    /**
-     * Limits how many events to accept using EventEmitter#on or EventEmitter#once
-     * @param limit Limit of events to keep
-     * @returns this with the new limit
-     * 
-     * @throws Unknown event, if event name isn't recognized
-     */
-     public limit<Event extends keyof Events>(eventName: 'all' | Event, limit: number) {
-        if (limit <= 0) return;
-        
-        if (eventName == 'all') {
-            this._limit = limit;
-            return this;
-        }
-        
-        const event = this.get(eventName);
-        if (!event) throw new Error(`Unknown event, ${eventName.toString()}!`);
+  /**
+   * Limits how many events to accept using EventEmitter#on or EventEmitter#once
+   * @param limit Limit of events to keep
+   * @returns this with the new limit
+   * 
+   * @throws Unknown event, if event name isn't recognized
+   */
+  public limit<Event extends keyof Events>(eventName: 'all' | Event, limit: number) {
+    if (limit <= 0) return;
 
-        event.limit = limit;
-        this._events.set(eventName, event as any);
-        return this;
+    if (eventName == 'all') {
+      this._limit = limit;
+      return this;
     }
+
+    const event = this.get(eventName);
+    if (!event) throw new Error(`Unknown event, ${eventName.toString()}!`);
+
+    event.limit = limit;
+    this._events.set(eventName, event as any);
+    return this;
+  }
 }
 export default EventCollection;

package/src/Classes/Events/EventEmitter.ts

@@ -32,77 +32,77 @@ import { BaseEvent, EventHandler } from '../../Types';
  * ```
  */
 export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
-    /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events?: Map<keyof Events, EventHandler<Events>>) {
-        this._events = new EventCollection(events);
-    }
+  /**@param events Map<name: string, handlers: EventHandler[]>*/
+  constructor(events?: Map<keyof Events, EventHandler<Events>>) {
+    this._events = new EventCollection(events);
+  }
 
-    /**@private Internal event collection*/
-    private _events = new EventCollection<Events>();
-    
-    /**
-     * Adds listener to event collection, and runs listener when event is emitted
-     * @param event Event to handle
-     * @param listener Callback function to run, when event occurs
-     * @returns this
-     */
-    public on<Return extends any, Event extends keyof Events>(
-        event: Event, 
-        listener: EventHandler<Events, Event, Return>
-    ): EventEmitter<Events> {
-        this._events.add(event, listener as any);
-        return this;
-    }
-    /**
-     * Adds listener to event collection, and runs listener once when event is emitted
-     * @param event Event to handle
-     * @param listener Callback function to run, when event occurs
-     * @returns this
-     */
-    public once<Return extends any, Event extends keyof Events>(
-        event: Event, 
-        listener: EventHandler<Events, Event, Return>
-    ): EventEmitter<Events> {
-        this._events.add(event, listener as any, true);
-        return this;
-    }
+  /**@private Internal event collection*/
+  private _events = new EventCollection<Events>();
 
-    /**
-     * Removes listener(s) from event
-     * @param event Event to get collection of listeners | "all"
-     * @param listener If left null, removes all listeners tied to event, else only removes listener from event
-     * @returns this
-     */
-    public off<Return extends any, Event extends keyof Events>(
-        event: Event | 'all' = "all", 
-        listener?: EventHandler<Events, Event, Return>
-    ): EventEmitter<Events> {
-        this._events.clear(event, listener);
-        return this;
-    }
+  /**
+   * Adds listener to event collection, and runs listener when event is emitted
+   * @param event Event to handle
+   * @param listener Callback function to run, when event occurs
+   * @returns this
+   */
+  public on<Return extends any, Event extends keyof Events>(
+    event: Event,
+    listener: EventHandler<Events, Event, Return>
+  ): EventEmitter<Events> {
+    this._events.add(event, listener as any);
+    return this;
+  }
+  /**
+   * Adds listener to event collection, and runs listener once when event is emitted
+   * @param event Event to handle
+   * @param listener Callback function to run, when event occurs
+   * @returns this
+   */
+  public once<Return extends any, Event extends keyof Events>(
+    event: Event,
+    listener: EventHandler<Events, Event, Return>
+  ): EventEmitter<Events> {
+    this._events.add(event, listener as any, true);
+    return this;
+  }
 
-    /**
-     * Emits event and runs all listeners tied to event
-     * @param event Event to emit
-     * @param args Arguments for the event
-     * @fires event
-     * @returns Array of listeners' reponses
-     */
-    public emit<Return extends any, Event extends keyof Events>(
-        event: Event, ...args: Events[Event]
-    ): Array<Return> {
-        return this._events.emit(event, ...args) as Array<Return>;
-    }
+  /**
+   * Removes listener(s) from event
+   * @param event Event to get collection of listeners | "all"
+   * @param listener If left null, removes all listeners tied to event, else only removes listener from event
+   * @returns this
+   */
+  public off<Return extends any, Event extends keyof Events>(
+    event: Event | 'all' = "all",
+    listener?: EventHandler<Events, Event, Return>
+  ): EventEmitter<Events> {
+    this._events.clear(event, listener);
+    return this;
+  }
 
-    /**
-     * Limits how many events to accept using EventEmitter#on or EventEmitter#once
-     * @param event: Specific event to limit, or by default, 'all'
-     * @param limit Limit of events to keep. If you want to limit amount of events saved, use 'all'.
-     * @returns this with the new limit
-     */
-    public limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events> {
-        this._events.limit<Event>(event, limit);
-        return this;
-    }
+  /**
+   * Emits event and runs all listeners tied to event
+   * @param event Event to emit
+   * @param args Arguments for the event
+   * @fires event
+   * @returns Array of listeners' responses
+   */
+  public emit<Return extends any, Event extends keyof Events>(
+    event: Event, ...args: Events[Event]
+  ): Array<Return> {
+    return this._events.emit(event, ...args) as Array<Return>;
+  }
+
+  /**
+   * Limits how many events to accept using EventEmitter#on or EventEmitter#once
+   * @param event: Specific event to limit, or by default, 'all'
+   * @param limit Limit of events to keep. If you want to limit amount of events saved, use 'all'.
+   * @returns this with the new limit
+   */
+  public limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events> {
+    this._events.limit<Event>(event, limit);
+    return this;
+  }
 }
 export default EventEmitter;