danholibraryjs 1.11.0 → 2.0.0

package/dist/Classes/Events/EventCollection.js

@@ -1,109 +1,109 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventCollection = void 0;
-const Event_1 = __importDefault(require("./Event"));
-/**
- * Collection of Events from @see EventEmitter
- * @borrows EventHandler
- * @borrows Event
- * @borrows BaseEvent
- */
-class EventCollection {
-    constructor(events) {
-        this._events = !events ?
-            new Map() :
-            events.array().reduce((result, [event, handlers]) => result.set(event, new Event_1.default(event, handlers)), new Map());
-    }
-    /**Amount of events stored*/
-    get size() {
-        return this._events.size;
-    }
-    /**@private Internal event collection*/
-    _events = new Map();
-    /**@private limit of events*/
-    _limit = 0;
-    /**
-     * Returns true if event is in collection
-     * @param event Event name
-     * @returns true if event is in collection
-     */
-    has(event) {
-        return this._events.has(event);
-    }
-    /**
-     * Returns event matching event parameter
-     * @param event Event name
-     * @returns Event
-     */
-    get(event) {
-        return this._events.get(event);
-    }
-    /**
-     * Adds handler to event collection with name as key
-     * @param name Event name
-     * @param handler Handler for event
-     * @returns this
-     */
-    add(name, handler, once = false) {
-        if (this._limit > 0 && this._limit + 1 > this._events.size) {
-            throw new Error(`Listener limit, ${this._limit}, reached!`);
-        }
-        const event = (this.has(name) && this.get(name)) || new Event_1.default(name);
-        this._events.set(name, event.on(handler, once));
-        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
-     */
-    clear(name = 'all', handler) {
-        const _name = name;
-        if (_name.toLowerCase() == 'all' && handler == null)
-            this._events.clear(); //clear(): Clears all events
-        else if (_name.toLowerCase() == 'all' && handler)
-            this._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;
-    }
-    emit(name, ...args) {
-        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
-     */
-    limit(eventName, limit) {
-        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()}!`);
-        event.limit = limit;
-        this._events.set(eventName, event);
-        return this;
-    }
-}
-exports.EventCollection = EventCollection;
-exports.default = EventCollection;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventCollection = void 0;
+const Event_1 = __importDefault(require("./Event"));
+/**
+ * Collection of Events from @see EventEmitter
+ * @borrows EventHandler
+ * @borrows Event
+ * @borrows BaseEvent
+ */
+class EventCollection {
+    constructor(events) {
+        this._events = !events ?
+            new Map() :
+            events.array().reduce((result, [event, handlers]) => result.set(event, new Event_1.default(event, handlers)), new Map());
+    }
+    /**Amount of events stored*/
+    get size() {
+        return this._events.size;
+    }
+    /**@private Internal event collection*/
+    _events = new Map();
+    /**@private limit of events*/
+    _limit = 0;
+    /**
+     * Returns true if event is in collection
+     * @param event Event name
+     * @returns true if event is in collection
+     */
+    has(event) {
+        return this._events.has(event);
+    }
+    /**
+     * Returns event matching event parameter
+     * @param event Event name
+     * @returns Event
+     */
+    get(event) {
+        return this._events.get(event);
+    }
+    /**
+     * Adds handler to event collection with name as key
+     * @param name Event name
+     * @param handler Handler for event
+     * @returns this
+     */
+    add(name, handler, once = false) {
+        if (this._limit > 0 && this._limit + 1 > this._events.size) {
+            throw new Error(`Listener limit, ${this._limit}, reached!`);
+        }
+        const event = (this.has(name) && this.get(name)) || new Event_1.default(name);
+        this._events.set(name, event.on(handler, once));
+        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
+     */
+    clear(name = 'all', handler) {
+        const _name = name;
+        if (_name.toLowerCase() == 'all' && handler == null)
+            this._events.clear(); //clear(): Clears all events
+        else if (_name.toLowerCase() == 'all' && handler)
+            this._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;
+    }
+    emit(name, ...args) {
+        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
+     */
+    limit(eventName, limit) {
+        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()}!`);
+        event.limit = limit;
+        this._events.set(eventName, event);
+        return this;
+    }
+}
+exports.EventCollection = EventCollection;
+exports.default = EventCollection;

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

@@ -1,74 +1,74 @@
-import { BaseEvent, EventHandler } from '../../Types';
-/**
- * Traditional Node.js EventEmitter for vanilla JavaScript
- * @borrows EventCollection
- * @borrows BaseEvent
- * @borrows EventHandler
- *
- * @example ```ts
- * import { EventEmitter } from 'danholibraryjs';
- *
- * type EventTypes = {
- *  create: [username: string, password: string],
- *  update: [id: string, user: User],
- *  delete: [id: string, reason?: string],
- * }
- *
- * const emitter = new EventEmitter<EventTypes>(new Map([
- *  ['create', (username, password) => {
- *     return { username, password };
- *  }],
- *  ['update', (id, user) => {
- *    return { id, ...user };
- *  }]
- * ]));
- *
- * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
- * emitter.on('delete', onDelete);
- * emitter.emit('delete', '1', 'No longer needed');
- * emitter.off('delete', onDelete);
- * ```
- */
-export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
-    /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events?: Map<keyof Events, EventHandler<Events>>);
-    /**@private Internal event collection*/
-    private _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
-     */
-    on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<Events>;
-    /**
-     * 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
-     */
-    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<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
-     */
-    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): EventEmitter<Events>;
-    /**
-     * 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
-     */
-    emit<Return extends any, Event extends keyof Events>(event: Event, ...args: Events[Event]): 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
-     */
-    limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events>;
-}
-export default EventEmitter;
+import { BaseEvent, EventHandler } from '../../Types';
+/**
+ * Traditional Node.js EventEmitter for vanilla JavaScript
+ * @borrows EventCollection
+ * @borrows BaseEvent
+ * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
+ */
+export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
+    /**@param events Map<name: string, handlers: EventHandler[]>*/
+    constructor(events?: Map<keyof Events, EventHandler<Events>>);
+    /**@private Internal event collection*/
+    private _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
+     */
+    on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<Events>;
+    /**
+     * 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
+     */
+    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<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
+     */
+    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): EventEmitter<Events>;
+    /**
+     * 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
+     */
+    emit<Return extends any, Event extends keyof Events>(event: Event, ...args: Events[Event]): 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
+     */
+    limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events>;
+}
+export default EventEmitter;

package/dist/Classes/Events/EventEmitter.js

@@ -1,97 +1,97 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEmitter = void 0;
-const EventCollection_1 = __importDefault(require("./EventCollection"));
-/**
- * Traditional Node.js EventEmitter for vanilla JavaScript
- * @borrows EventCollection
- * @borrows BaseEvent
- * @borrows EventHandler
- *
- * @example ```ts
- * import { EventEmitter } from 'danholibraryjs';
- *
- * type EventTypes = {
- *  create: [username: string, password: string],
- *  update: [id: string, user: User],
- *  delete: [id: string, reason?: string],
- * }
- *
- * const emitter = new EventEmitter<EventTypes>(new Map([
- *  ['create', (username, password) => {
- *     return { username, password };
- *  }],
- *  ['update', (id, user) => {
- *    return { id, ...user };
- *  }]
- * ]));
- *
- * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
- * emitter.on('delete', onDelete);
- * emitter.emit('delete', '1', 'No longer needed');
- * emitter.off('delete', onDelete);
- * ```
- */
-class EventEmitter {
-    /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events) {
-        this._events = new EventCollection_1.default(events);
-    }
-    /**@private Internal event collection*/
-    _events = new EventCollection_1.default();
-    /**
-     * 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
-     */
-    on(event, listener) {
-        this._events.add(event, listener);
-        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
-     */
-    once(event, listener) {
-        this._events.add(event, listener, true);
-        return this;
-    }
-    /**
-     * 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
-     */
-    off(event = "all", listener) {
-        this._events.clear(event, listener);
-        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
-     */
-    emit(event, ...args) {
-        return this._events.emit(event, ...args);
-    }
-    /**
-     * 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
-     */
-    limit(event, limit) {
-        this._events.limit(event, limit);
-        return this;
-    }
-}
-exports.EventEmitter = EventEmitter;
-exports.default = EventEmitter;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+const EventCollection_1 = __importDefault(require("./EventCollection"));
+/**
+ * Traditional Node.js EventEmitter for vanilla JavaScript
+ * @borrows EventCollection
+ * @borrows BaseEvent
+ * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
+ */
+class EventEmitter {
+    /**@param events Map<name: string, handlers: EventHandler[]>*/
+    constructor(events) {
+        this._events = new EventCollection_1.default(events);
+    }
+    /**@private Internal event collection*/
+    _events = new EventCollection_1.default();
+    /**
+     * 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
+     */
+    on(event, listener) {
+        this._events.add(event, listener);
+        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
+     */
+    once(event, listener) {
+        this._events.add(event, listener, true);
+        return this;
+    }
+    /**
+     * 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
+     */
+    off(event = "all", listener) {
+        this._events.clear(event, listener);
+        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
+     */
+    emit(event, ...args) {
+        return this._events.emit(event, ...args);
+    }
+    /**
+     * 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
+     */
+    limit(event, limit) {
+        this._events.limit(event, limit);
+        return this;
+    }
+}
+exports.EventEmitter = EventEmitter;
+exports.default = EventEmitter;

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

@@ -1,3 +1,3 @@
-export * from './Event';
-export * from './EventCollection';
-export * from './EventEmitter';
+export * from './Event';
+export * from './EventCollection';
+export * from './EventEmitter';

package/dist/Classes/Events/index.js

@@ -1,19 +1,19 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Event"), exports);
-__exportStar(require("./EventCollection"), exports);
-__exportStar(require("./EventEmitter"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Event"), exports);
+__exportStar(require("./EventCollection"), exports);
+__exportStar(require("./EventEmitter"), exports);