danholibraryjs 1.10.0 → 2.0.0

package/src/Classes/DanhoLogger.ts

@@ -0,0 +1,78 @@
+type LogOptions = {
+  name?: string;
+  color?: string;
+  preferCollapsed?: boolean;
+}
+
+export default class DanhoLogger {
+  public name: string;
+  public color?: string
+  private _preferCollapsed: boolean;
+  
+  constructor(options: LogOptions = {}) {
+    this.name = options.name || 'DanhoLogger';
+    this.color = options.color;
+    this._preferCollapsed = options.preferCollapsed ?? false;
+  }
+
+  private _getPrefix() {
+    return {
+      prefix: `%c[${this.name}]`,
+      style: `color: ${this.color || 'inherit'}; font-weight: bold;`
+    };
+  }
+  private _log(
+    type: 'log' | 'warn' | 'error',
+    ...args: any[]
+  ) {
+    const { prefix, style } = this._getPrefix();
+    console[type](prefix, style, ...args);
+    return this;
+  }
+
+  public log(...args: any[]) {
+    return this._log('log', ...args);
+  }
+  public warn(...args: any[]) {
+    return this._log('warn', ...args);
+  }
+  public error(...args: any[]) {
+    return this._log('error', ...args);
+  }
+
+  public group(...args: any[]) {
+    const { prefix, style } = this._getPrefix();
+
+    const groupMethod = this._preferCollapsed ? console.groupCollapsed : console.group;
+    groupMethod(prefix, style, ...args);
+    
+    return this;
+  }
+  public groupCollapsed(...args: any[]) {
+    const { prefix, style } = this._getPrefix();
+    console.groupCollapsed(prefix, style, ...args);
+    return this;
+  }
+  public groupEnd(...args: any[]) {
+    if (args.length) console.log(...args);
+    console.groupEnd();
+    return this;
+  }
+
+  time(label: string) {
+    const { prefix } = this._getPrefix();
+    console.time(`${prefix} ${label}`);
+    return this;
+  }
+  timeEnd(label: string) {
+    const { prefix } = this._getPrefix();
+    console.timeEnd(`${prefix} ${label}`);
+    return this;
+  }
+
+  table(data: any, columns?: string[]) {
+    this.log();
+    console.table(data, columns);
+    return this;
+  }
+}

package/src/Classes/Events/Event.ts

@@ -4,111 +4,111 @@ import { BaseEvent, EventHandler } from "../../Types/Events";
  * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
  */
 export class Event<
-    Events extends BaseEvent<string, Array<any>>,
-    Name extends keyof Events = keyof Events,
+  Events extends BaseEvent<string, Array<any>>,
+  Name extends keyof Events = keyof Events,
 > {
-    /**
-     * Base event for @see EventEmitter, @borrows EventHandler
-     * @param name Name of event
-     * @param listeners Listeners/Handlers to execute when emitted
-     */
-    constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>) {
-        this.name = name;
-        this._listeners = listeners;
-        this._lastEmitted = new Date();
-    }
+  /**
+   * Base event for @see EventEmitter, @borrows EventHandler
+   * @param name Name of event
+   * @param listeners Listeners/Handlers to execute when emitted
+   */
+  constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>) {
+    this.name = name;
+    this._listeners = listeners;
+    this._lastEmitted = new Date();
+  }
 
-    /**Name of event*/
-    public name: Name;
-    /**Listener limit - default: 0 */
-    public limit = 0;
-    /**Number of times event was emitted - default: 0*/
-    public get runs() {
-        return this._runs
-    }
-    /**Timestamp of last emit - default: null*/
-    public get lastEmitted() {
-        return this._lastEmitted;
-    }
+  /**Name of event*/
+  public name: Name;
+  /**Listener limit - default: 0 */
+  public limit = 0;
+  /**Number of times event was emitted - default: 0*/
+  public get runs() {
+    return this._runs;
+  }
+  /**Timestamp of last emit - default: null*/
+  public get lastEmitted() {
+    return this._lastEmitted;
+  }
 
-    /**@private Internal listeners array*/
-    private _listeners: Array<EventHandler<Events, Name>>;
-    /**@private Internal runs*/
-    private _runs = 0;
-    /**@private Internal lastEmitted*/
-    private _lastEmitted: Date;
+  /**@private Internal listeners array*/
+  private _listeners: Array<EventHandler<Events, Name>>;
+  /**@private Internal runs*/
+  private _runs = 0;
+  /**@private Internal lastEmitted*/
+  private _lastEmitted: Date;
 
-    /**
-     * Emits event and returns array of responses
-     * @param args Arguments required for event listeners
-     * @returns Return values of listeners' returns
-     */
-    public emit(...args: Events[Name]) {
-        this._runs++;
-        this._lastEmitted = new Date();
-        return this._listeners.map(listener => (listener as any)(...args))
+  /**
+   * Emits event and returns array of responses
+   * @param args Arguments required for event listeners
+   * @returns Return values of listeners' returns
+   */
+  public emit(...args: Events[Name]) {
+    this._runs++;
+    this._lastEmitted = new Date();
+    return this._listeners.map(listener => (listener as any)(...args));
+  }
+  /**
+   * Adds listener to listeners array and returns self with new listener added
+   * @param listener Listener to add
+   * @param prepend Add first (true) or last (false) - default: false
+   * @returns this with listener added
+   * 
+   * @throws Limit error, if limit was reached
+   */
+  public on(listener: EventHandler<Events, Name>, prepend = false) {
+    if (this.limit > 0 && this._listeners.length + 1 > this.limit) {
+      throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
     }
-    /**
-     * Adds listener to listeners array and returns self with new listener added
-     * @param listener Listener to add
-     * @param prepend Add first (true) or last (false) - default: false
-     * @returns this with listener added
-     * 
-     * @throws Limit error, if limit was reached
-     */
-    public on(listener: EventHandler<Events, Name>, prepend = false) {
-        if (this.limit > 0 && this._listeners.length + 1 > this.limit) {
-            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
-        }
 
-        if (prepend) this._listeners = [listener, ...this._listeners]
-        else this._listeners.add(listener);
+    if (prepend) this._listeners = [listener, ...this._listeners];
+    else this._listeners.add(listener);
 
-        return this;
-    }
-    /**
-     * Like Event#on, adds listener to listeners array and returns self with new listener added, however removes listener once emitted
-     * @param listener Listener to add
-     * @param prepend Add first (true) or last (false) - default: false
-     * @returns this with listener added
-     * 
-     * @throws Limit error, if limit was reached
-     */
-    public once(listener: EventHandler<Events, Name>, prepend = false) {
-        const handler = (...params: Events[Name]) => {
-            const result = (listener as any)(...params);
-            this.off(handler as any);
-            return result;
-        }
-        this.on(handler as any, prepend);
-        return this;
-    }
+    return this;
+  }
+  /**
+   * Like Event#on, adds listener to listeners array and returns self with new listener added, however removes listener once emitted
+   * @param listener Listener to add
+   * @param prepend Add first (true) or last (false) - default: false
+   * @returns this with listener added
+   * 
+   * @throws Limit error, if limit was reached
+   */
+  public once(listener: EventHandler<Events, Name>, prepend = false) {
+    const handler = (...params: Events[Name]) => {
+      const result = (listener as any)(...params);
+      this.off(handler as any);
+      return result;
+    };
+    this.on(handler as any, prepend);
+    return this;
+  }
 
-    /**
-     * Returns true or false, depending if event includes listener
-     * @param listener Listener to test
-     * @returns True of false, depending if event includes listener
-     */
-    public includes(listener: EventHandler<Events, Name>) {
-        return this._listeners.includes(listener);
-    }
+  /**
+   * Returns true or false, depending if event includes listener
+   * @param listener Listener to test
+   * @returns True of false, depending if event includes listener
+   */
+  public includes(listener: EventHandler<Events, Name>) {
+    return this._listeners.includes(listener);
+  }
 
-    /**
-     * Removes listener from internal listeners array
-     * @param listener Listener to remove. If none specified, all will be removed
-     * @param throwNotFoundError Throw error if listener isn't in listeners array - default: false
-     * @returns this, without listener
-     * 
-     * @throws NotFound, if throwNotFoundError is true, and internal listeners array doesn't include listener provided
-     */
-    public off(listener?: EventHandler<Events, Name>, throwNotFoundError = false) {
-        try { 
-            if (!listener) this._listeners = new Array<EventHandler<Events, Name>>()
-            else if (!this._listeners.includes(listener)) return this;
-            else this._listeners.remove(listener);
-         } 
-        catch (err) { if (throwNotFoundError) throw err; }
-        return this;
+  /**
+   * Removes listener from internal listeners array
+   * @param listener Listener to remove. If none specified, all will be removed
+   * @param throwNotFoundError Throw error if listener isn't in listeners array - default: false
+   * @returns this, without listener
+   * 
+   * @throws NotFound, if throwNotFoundError is true, and internal listeners array doesn't include listener provided
+   */
+  public off(listener?: EventHandler<Events, Name>, throwNotFoundError = false) {
+    try {
+      if (!listener) this._listeners = new Array<EventHandler<Events, Name>>();
+      else if (!this._listeners.includes(listener)) return this;
+      else this._listeners.remove(listener);
     }
+    catch (err) { if (throwNotFoundError) throw err; }
+    return this;
+  }
 }
 export default Event;

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;