danholibraryjs 1.11.0 → 2.0.1

package/README.md

@@ -24,6 +24,5 @@ import { ... } from 'DanhoLibraryJS';
 
 * [Classes](/docs/Classes.md)
 * [Extensions](/docs/Extensions.md)
-* [Functions](/docs/Functions.md)
 * [Interfaces](/docs/Interfaces.md)
 * [Types](/docs/Types.md)

package/_package.github-release.json

@@ -0,0 +1,6 @@
+{
+  "name": "@danielsimonsen90/danholibraryjs",
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/"
+  }
+}

package/_package.npm-release.json

@@ -0,0 +1,6 @@
+{
+  "name": "danholibraryjs",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/dist/Classes/DanhoLogger.d.ts

@@ -0,0 +1,23 @@
+type LogOptions = {
+    name?: string;
+    color?: string;
+    preferCollapsed?: boolean;
+};
+export default class DanhoLogger {
+    name: string;
+    color?: string;
+    private _preferCollapsed;
+    constructor(options?: LogOptions);
+    private _getPrefix;
+    private _log;
+    log(...args: any[]): this;
+    warn(...args: any[]): this;
+    error(...args: any[]): this;
+    group(...args: any[]): this;
+    groupCollapsed(...args: any[]): this;
+    groupEnd(...args: any[]): this;
+    time(label: string): this;
+    timeEnd(label: string): this;
+    table(data: any, columns?: string[]): this;
+}
+export {};

package/dist/Classes/DanhoLogger.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DanhoLogger {
+    name;
+    color;
+    _preferCollapsed;
+    constructor(options = {}) {
+        this.name = options.name || 'DanhoLogger';
+        this.color = options.color;
+        this._preferCollapsed = options.preferCollapsed ?? false;
+    }
+    _getPrefix() {
+        return {
+            prefix: `%c[${this.name}]`,
+            style: `color: ${this.color || 'inherit'}; font-weight: bold;`
+        };
+    }
+    _log(type, ...args) {
+        const { prefix, style } = this._getPrefix();
+        console[type](prefix, style, ...args);
+        return this;
+    }
+    log(...args) {
+        return this._log('log', ...args);
+    }
+    warn(...args) {
+        return this._log('warn', ...args);
+    }
+    error(...args) {
+        return this._log('error', ...args);
+    }
+    group(...args) {
+        const { prefix, style } = this._getPrefix();
+        const groupMethod = this._preferCollapsed ? console.groupCollapsed : console.group;
+        groupMethod(prefix, style, ...args);
+        return this;
+    }
+    groupCollapsed(...args) {
+        const { prefix, style } = this._getPrefix();
+        console.groupCollapsed(prefix, style, ...args);
+        return this;
+    }
+    groupEnd(...args) {
+        if (args.length)
+            console.log(...args);
+        console.groupEnd();
+        return this;
+    }
+    time(label) {
+        const { prefix } = this._getPrefix();
+        console.time(`${prefix} ${label}`);
+        return this;
+    }
+    timeEnd(label) {
+        const { prefix } = this._getPrefix();
+        console.timeEnd(`${prefix} ${label}`);
+        return this;
+    }
+    table(data, columns) {
+        this.log();
+        console.table(data, columns);
+        return this;
+    }
+}
+exports.default = DanhoLogger;

package/dist/Classes/Events/Event.d.ts

@@ -1,66 +1,66 @@
-import { BaseEvent, EventHandler } from "../../Types/Events";
-/**
- * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
- */
-export declare class Event<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>>);
-    /**Name of event*/
-    name: Name;
-    /**Listener limit - default: 0 */
-    limit: number;
-    /**Number of times event was emitted - default: 0*/
-    get runs(): number;
-    /**Timestamp of last emit - default: null*/
-    get lastEmitted(): Date;
-    /**@private Internal listeners array*/
-    private _listeners;
-    /**@private Internal runs*/
-    private _runs;
-    /**@private Internal lastEmitted*/
-    private _lastEmitted;
-    /**
-     * Emits event and returns array of responses
-     * @param args Arguments required for event listeners
-     * @returns Return values of listeners' returns
-     */
-    emit(...args: Events[Name]): any[];
-    /**
-     * 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
-     */
-    on(listener: EventHandler<Events, Name>, prepend?: boolean): 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
-     */
-    once(listener: EventHandler<Events, Name>, prepend?: boolean): this;
-    /**
-     * Returns true or false, depending if event includes listener
-     * @param listener Listener to test
-     * @returns True of false, depending if event includes listener
-     */
-    includes(listener: EventHandler<Events, Name>): boolean;
-    /**
-     * 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
-     */
-    off(listener?: EventHandler<Events, Name>, throwNotFoundError?: boolean): this;
-}
-export default Event;
+import { BaseEvent, EventHandler } from "../../Types/Events";
+/**
+ * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
+ */
+export declare class Event<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>>);
+    /**Name of event*/
+    name: Name;
+    /**Listener limit - default: 0 */
+    limit: number;
+    /**Number of times event was emitted - default: 0*/
+    get runs(): number;
+    /**Timestamp of last emit - default: null*/
+    get lastEmitted(): Date;
+    /**@private Internal listeners array*/
+    private _listeners;
+    /**@private Internal runs*/
+    private _runs;
+    /**@private Internal lastEmitted*/
+    private _lastEmitted;
+    /**
+     * Emits event and returns array of responses
+     * @param args Arguments required for event listeners
+     * @returns Return values of listeners' returns
+     */
+    emit(...args: Events[Name]): any[];
+    /**
+     * 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
+     */
+    on(listener: EventHandler<Events, Name>, prepend?: boolean): 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
+     */
+    once(listener: EventHandler<Events, Name>, prepend?: boolean): this;
+    /**
+     * Returns true or false, depending if event includes listener
+     * @param listener Listener to test
+     * @returns True of false, depending if event includes listener
+     */
+    includes(listener: EventHandler<Events, Name>): boolean;
+    /**
+     * 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
+     */
+    off(listener?: EventHandler<Events, Name>, throwNotFoundError?: boolean): this;
+}
+export default Event;

package/dist/Classes/Events/Event.js

@@ -1,114 +1,114 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Event = void 0;
-/**
- * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
- */
-class Event {
-    /**
-     * Base event for @see EventEmitter, @borrows EventHandler
-     * @param name Name of event
-     * @param listeners Listeners/Handlers to execute when emitted
-     */
-    constructor(name, ...listeners) {
-        this.name = name;
-        this._listeners = listeners;
-        this._lastEmitted = new Date();
-    }
-    /**Name of event*/
-    name;
-    /**Listener limit - default: 0 */
-    limit = 0;
-    /**Number of times event was emitted - default: 0*/
-    get runs() {
-        return this._runs;
-    }
-    /**Timestamp of last emit - default: null*/
-    get lastEmitted() {
-        return this._lastEmitted;
-    }
-    /**@private Internal listeners array*/
-    _listeners;
-    /**@private Internal runs*/
-    _runs = 0;
-    /**@private Internal lastEmitted*/
-    _lastEmitted;
-    /**
-     * Emits event and returns array of responses
-     * @param args Arguments required for event listeners
-     * @returns Return values of listeners' returns
-     */
-    emit(...args) {
-        this._runs++;
-        this._lastEmitted = new Date();
-        return this._listeners.map(listener => listener(...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
-     */
-    on(listener, 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);
-        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
-     */
-    once(listener, prepend = false) {
-        const handler = (...params) => {
-            const result = listener(...params);
-            this.off(handler);
-            return result;
-        };
-        this.on(handler, 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
-     */
-    includes(listener) {
-        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
-     */
-    off(listener, throwNotFoundError = false) {
-        try {
-            if (!listener)
-                this._listeners = new Array();
-            else if (!this._listeners.includes(listener))
-                return this;
-            else
-                this._listeners.remove(listener);
-        }
-        catch (err) {
-            if (throwNotFoundError)
-                throw err;
-        }
-        return this;
-    }
-}
-exports.Event = Event;
-exports.default = Event;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+/**
+ * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
+ */
+class Event {
+    /**
+     * Base event for @see EventEmitter, @borrows EventHandler
+     * @param name Name of event
+     * @param listeners Listeners/Handlers to execute when emitted
+     */
+    constructor(name, ...listeners) {
+        this.name = name;
+        this._listeners = listeners;
+        this._lastEmitted = new Date();
+    }
+    /**Name of event*/
+    name;
+    /**Listener limit - default: 0 */
+    limit = 0;
+    /**Number of times event was emitted - default: 0*/
+    get runs() {
+        return this._runs;
+    }
+    /**Timestamp of last emit - default: null*/
+    get lastEmitted() {
+        return this._lastEmitted;
+    }
+    /**@private Internal listeners array*/
+    _listeners;
+    /**@private Internal runs*/
+    _runs = 0;
+    /**@private Internal lastEmitted*/
+    _lastEmitted;
+    /**
+     * Emits event and returns array of responses
+     * @param args Arguments required for event listeners
+     * @returns Return values of listeners' returns
+     */
+    emit(...args) {
+        this._runs++;
+        this._lastEmitted = new Date();
+        return this._listeners.map(listener => listener(...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
+     */
+    on(listener, 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);
+        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
+     */
+    once(listener, prepend = false) {
+        const handler = (...params) => {
+            const result = listener(...params);
+            this.off(handler);
+            return result;
+        };
+        this.on(handler, 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
+     */
+    includes(listener) {
+        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
+     */
+    off(listener, throwNotFoundError = false) {
+        try {
+            if (!listener)
+                this._listeners = new Array();
+            else if (!this._listeners.includes(listener))
+                return this;
+            else
+                this._listeners.remove(listener);
+        }
+        catch (err) {
+            if (throwNotFoundError)
+                throw err;
+        }
+        return this;
+    }
+}
+exports.Event = Event;
+exports.default = Event;

package/dist/Classes/Events/EventCollection.d.ts

@@ -1,57 +1,57 @@
-import { BaseEvent, EventHandler } from "../../Types/Events";
-import Event from './Event';
-/**
- * Collection of Events from @see EventEmitter
- * @borrows EventHandler
- * @borrows Event
- * @borrows BaseEvent
- */
-export declare class EventCollection<Events extends BaseEvent<string, Array<any>>> {
-    constructor(events?: Map<keyof Events, EventHandler<Events>>);
-    /**Amount of events stored*/
-    get size(): number;
-    /**@private Internal event collection*/
-    private _events;
-    /**@private limit of events*/
-    private _limit;
-    /**
-     * Returns true if event is in collection
-     * @param event Event name
-     * @returns true if event is in collection
-     */
-    has<EventName extends keyof Events>(event: EventName): boolean;
-    /**
-     * Returns event matching event parameter
-     * @param event Event name
-     * @returns Event
-     */
-    get<EventName extends keyof Events>(event: EventName): Event<Events, EventName>;
-    /**
-     * Adds handler to event collection with name as key
-     * @param name Event name
-     * @param handler Handler for event
-     * @returns this
-     */
-    add<EventName extends keyof Events>(name: EventName, handler: EventHandler<Events, keyof Events>, once?: boolean): 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
-     */
-    clear<EventName extends keyof Events>(name?: EventName | 'all', handler?: EventHandler): this;
-    emit<Event extends keyof Events>(name: Event, ...args: Events[Event]): any[];
-    /**
-     * 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
-     */
-    limit<Event extends keyof Events>(eventName: 'all' | Event, limit: number): this | undefined;
-}
-export default EventCollection;
+import { BaseEvent, EventHandler } from "../../Types/Events";
+import Event from './Event';
+/**
+ * Collection of Events from @see EventEmitter
+ * @borrows EventHandler
+ * @borrows Event
+ * @borrows BaseEvent
+ */
+export declare class EventCollection<Events extends BaseEvent<string, Array<any>>> {
+    constructor(events?: Map<keyof Events, EventHandler<Events>>);
+    /**Amount of events stored*/
+    get size(): number;
+    /**@private Internal event collection*/
+    private _events;
+    /**@private limit of events*/
+    private _limit;
+    /**
+     * Returns true if event is in collection
+     * @param event Event name
+     * @returns true if event is in collection
+     */
+    has<EventName extends keyof Events>(event: EventName): boolean;
+    /**
+     * Returns event matching event parameter
+     * @param event Event name
+     * @returns Event
+     */
+    get<EventName extends keyof Events>(event: EventName): Event<Events, EventName>;
+    /**
+     * Adds handler to event collection with name as key
+     * @param name Event name
+     * @param handler Handler for event
+     * @returns this
+     */
+    add<EventName extends keyof Events>(name: EventName, handler: EventHandler<Events, keyof Events>, once?: boolean): 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
+     */
+    clear<EventName extends keyof Events>(name?: EventName | 'all', handler?: EventHandler): this;
+    emit<Event extends keyof Events>(name: Event, ...args: Events[Event]): any[];
+    /**
+     * 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
+     */
+    limit<Event extends keyof Events>(eventName: 'all' | Event, limit: number): this | undefined;
+}
+export default EventCollection;