danholibraryjs 1.3.0 → 1.7.0

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -1,13 +1,18 @@
 # DanhoLibraryJS
+
 [By DanielSimonsen90 // Danhosaur](https://github.com/DanielSimonsen90)
 
+## Installation
+
 ### Vanilla
+
 ```html
 <script src="https://cdn.jsdelivr.net/gh/DanielSimonsen90/DanhoLibraryJS@latest/dist/index.js"></script>
 ```
 
 ### Node
-```
+
+```cmd
 npm install danholibraryjs
 ```
 
@@ -15,307 +20,10 @@ npm install danholibraryjs
 import { ... } from 'DanhoLibraryJS';
 ```
 
-### Documentation
-#### Extensions
-```ts
-class Document {
-    /**
-     * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
-     * @param tagName HTMLElement tag name
-     * @param options Construction options, instead of assigning values after construction
-     */
-    createProperElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementOptions<K>): HTMLElementTagNameMap[K];
-}
-
-class HTMLCollection {
-    /**Converts HTMLCollection to Element[]*/
-    array(): Element[];
-}
-
-class Array<T> {
-    /**
-     * Pushes items to array and returns self with new items
-     * @param items Items to add to array
-     */
-    add(...items: Array<T>): this
-    /**
-     * Removes item from array and returns self without item
-     * @param item Item to remove
-     */
-    remove(item: T): this
-}
-
-interface Map<K, V> {
-    /**Converts map into Array<[Key, Value]>*/
-    array(): [K, V][]
-    /**
-     * Maps values into new types of generics
-     * @param callback Callbacking function to map values
-     */
-    map<EK, EV>(callback: (value: V, key?: K, index?: number, map?: this) => [EK, EV]): Map<EK, EV>
-    /**
-     * Returns array of "accepted" values. Criteria defined in callback param
-     * @param callback Callbacking function to filter away unwanted values
-     */
-    filter(callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): Map<K, V>
-    /**Converts map into array of keys*/
-    keyArr(): Array<K>
-    /**Converts map into array of values*/
-    valueArr(): Array<V>
-    /**
-     * Returns first [key, value] match to callback param
-     * @param callback Callbacking function to find KeyValuePair
-     */
-    find(callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): [K, V]
-    /**
-     * Whether or not map includes a  value (value version of Map#has)
-     * @param value Value that may be includded in map
-     * @param fromIndex Start looking for value from specific index+. Default: 0
-     */
-    includes(value: V, fromIndex?: number): boolean;
-}
-interface String {
-    /**Uppercases first letter of string*/
-    toPascalCase(): string
-    /**
-     * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
-     * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-     */
-    toSnakeCase(replaceOptions?: IReplacement): string
-    /**
-     * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
-     * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-     */
-    toKebabCase(replaceOptions?: IReplacement): string
-}
-```
-
-#### Functions
-```ts
-/**
- * Copies value to clipboard and alerts a response, if response is defined
- * @param value Value to clipboard
- * @param response Alerts if response is given
- */
-async function CopyToClipboard(value: string, response?: string): Promise<void>;
-
-/**
- * Appends classes to header's "a" elements, when navigation to "a"'s page is selected
- * @param query The query selector for Document.querySelector
- * @param currentPageClasses Class(es) to append header's "a" elements
- * 
- * @borrows Document.querySelector
- */
-function SetNavigationSelected(query: string, ...currentPageClasses: string[]): void;
-```
-
-#### Classes
-```ts
-/**Base event for @see EventEmitter, @borrows EventHandler*/
-class Event<ReturnType = any> {
-    /**
-     * Base event for @see EventEmitter, @borrows EventHandler
-     * @param name Name of event
-     * @param listeners Listeners/Handlers to execute when emitted
-     */
-    constructor(name: string, ...listeners: Array<EventHandler<ReturnType>>);
-
-    /**Name of event*/
-    public name: string;
-    /**Listener limit - default: 0 */
-    public limit = 0;
-    /**Number of times event was emitted - default: 0*/
-    public get runs: number;
-    /**Timestamp of last emit - default: null*/
-    public get 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: any[]): 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
-     */
-    public on(listener: EventHandler<ReturnType>, prepend = false): 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<ReturnType>, prepend = false): 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<ReturnType>): boolean;
-    /**
-     * Removes listener from internal listeners array
-     * @param listener Listener to remove
-     * @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<ReturnType>, throwNotFoundError = false): this;
-}
-
-class EventCollection {
-    /**
-     * Collection of Events from @see EventEmitter
-     * @borrows EventHandler
-     * @borrows Event
-     */
-    /**Events to add in construction - Map<eventName, eventHandlers>*/
-    constructor(events?: Map<string, EventHandler[]>);
-    /**Amount of events stored*/
-    readonly size: number;
-    /**
-     * Returns true if event is in collection
-     * @param event Event name
-     * @returns true if event is in collection
-     */
-    has(event: string): boolean;
-    /**
-     * Returns all event handlers for event name. T is return type for event
-     * @param event Event name
-     * @returns Event object stored
-     */
-    get<T = any>(event: string): Event<T>
-    /**
-     * Adds handler to event collection with name as key
-     * @param name Event name
-     * @param handler Handler for event
-     * @param once Whether or not handler only should run once or all times
-     * @returns this
-     */
-    add(name: string, handler: EventHandler, once = false): 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?: string | "all", handler?: EventHandler): this;
-    /**
-     * Emits event matching name, and provides args param to saved handers. Returns result from all handlers
-     * @param name Event name
-     * @param args Arguments for event handlers
-     * @returns Result from all handlers
-     */
-    emit(name: string, ...args: any[]): 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: 'all' | string, limit: number): this
-}
-
-/**Traditional Node.js EventEmitter in vanilla JavaScript*/
-class EventEmitter {
-    /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events?: Map<string, EventHandler[]>);
-
-    /**
-     * 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<ReturnType = any>(event: string, listener: EventHandler<ReturnType>): 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: string, listener: EventHandler): 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: string = 'all', listener?: EventHandler): 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<ReturnType = any>(event: string, ...args: any[]): ReturnType[];
-    /**
-     * 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: 'all' | string, limit: number): this;
-}
-```
-
-#### Interfaces
-```ts
-/**Options for creating a proper HTML element*/
-interface ElementOptions<K extends keyof HTMLElementTagNameMap> {
-    /**css classes to give the element*/
-    classes?: string[];
-    /**attributes to give the element*/
-    attributes?: [string, string][];
-    /**Children of the element*/
-    children?: HTMLElementTagNameMap[K][];
-    /**Events for the element to listen to
-     * @borrows EventHandler
-     */
-    events?: Array<{ name: string, handlers: EventHandler[] }>
-}
-/**
- * Replacement tool for 
- * @see String.toSnakeCase 
- * @see String.toKebabCase
- * @borrows StringRegex
-*/
-interface IReplacement {
-    replacer?: StringRegex,
-    replacement?: string
-}
-```
-
-#### Types
-```ts
-/**
- * Eventhandler type for:
- * @see EventCollection
- */
-type EventHandler<ReturnType = any> = (...args: any[]) => ReturnType;
-
-/**
- * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
- * IElement accepts HTML Elements or HTMl-like strings.
- * 
- * @see HTMLElement.append
- * @see Document.createProperElement
- */
-type IElement = HTMLElement | string;
+## Documentation
 
-/**Used for @see IReplacement*/
-type StringRegex = string | RegExp;
-```
+* [Classes](/docs/Classes.md)
+* [Extensions](/docs/Extensions.md)
+* [Functions](/docs/Functions.md)
+* [Interfaces](/docs/Interfaces.md)
+* [Types](/docs/Types.md)

package/dist/Classes/{Event.d.ts → Events/Event.d.ts}

@@ -1,14 +1,16 @@
-import EventHandler from "../Types/EventHandler";
-/**Base event for @see EventEmitter, @borrows EventHandler*/
-export default class Event<ReturnType = any> {
+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: string, ...listeners: Array<EventHandler<ReturnType>>);
+    constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>);
     /**Name of event*/
-    name: string;
+    name: Name;
     /**Listener limit - default: 0 */
     limit: number;
     /**Number of times event was emitted - default: 0*/
@@ -26,7 +28,7 @@ export default class Event<ReturnType = any> {
      * @param args Arguments required for event listeners
      * @returns Return values of listeners' returns
      */
-    emit(...args: any[]): ReturnType[];
+    emit(...args: Events[Name]): any[];
     /**
      * Adds listener to listeners array and returns self with new listener added
      * @param listener Listener to add
@@ -35,7 +37,7 @@ export default class Event<ReturnType = any> {
      *
      * @throws Limit error, if limit was reached
      */
-    on(listener: EventHandler<ReturnType>, prepend?: boolean): this;
+    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
@@ -44,20 +46,21 @@ export default class Event<ReturnType = any> {
      *
      * @throws Limit error, if limit was reached
      */
-    once(listener: EventHandler<ReturnType>, prepend?: boolean): this;
+    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<ReturnType>): boolean;
+    includes(listener: EventHandler<Events, Name>): boolean;
     /**
      * Removes listener from internal listeners array
-     * @param listener Listener to remove
+     * @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<ReturnType>, throwNotFoundError?: boolean): this;
+    off(listener?: EventHandler<Events, Name>, throwNotFoundError?: boolean): this;
 }
+export default Event;

package/dist/Classes/{Event.js → Events/Event.js}

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/**Base event for @see EventEmitter, @borrows EventHandler*/
+exports.Event = void 0;
+/**
+ * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
+ */
 class Event {
     /**
      * Base event for @see EventEmitter, @borrows EventHandler
@@ -10,6 +13,7 @@ class Event {
     constructor(name, ...listeners) {
         this.name = name;
         this._listeners = listeners;
+        this._lastEmitted = new Date();
     }
     /**Name of event*/
     name;
@@ -28,7 +32,7 @@ class Event {
     /**@private Internal runs*/
     _runs = 0;
     /**@private Internal lastEmitted*/
-    _lastEmitted = null;
+    _lastEmitted;
     /**
      * Emits event and returns array of responses
      * @param args Arguments required for event listeners
@@ -66,8 +70,8 @@ class Event {
      * @throws Limit error, if limit was reached
      */
     once(listener, prepend = false) {
-        const handler = (...args) => {
-            const result = listener(...args);
+        const handler = (...params) => {
+            const result = listener(...params);
             this.off(handler);
             return result;
         };
@@ -84,7 +88,7 @@ class Event {
     }
     /**
      * Removes listener from internal listeners array
-     * @param listener Listener to remove
+     * @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
      *
@@ -92,7 +96,12 @@ class Event {
      */
     off(listener, throwNotFoundError = false) {
         try {
-            this._listeners.remove(listener);
+            if (!listener)
+                this._listeners = new Array();
+            else if (!this._listeners.includes(listener))
+                return this;
+            else
+                this._listeners.remove(listener);
         }
         catch (err) {
             if (throwNotFoundError)
@@ -101,4 +110,5 @@ class Event {
         return this;
     }
 }
+exports.Event = Event;
 exports.default = Event;

package/dist/Classes/{EventCollection.d.ts → Events/EventCollection.d.ts}

@@ -1,12 +1,13 @@
-import EventHandler from "../Types/EventHandler";
+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 {
-    constructor(events?: Map<string, EventHandler[]>);
+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*/
@@ -18,20 +19,20 @@ export declare class EventCollection {
      * @param event Event name
      * @returns true if event is in collection
      */
-    has(event: string): boolean;
+    has<EventName extends keyof Events>(event: EventName): boolean;
     /**
      * Returns event matching event parameter
      * @param event Event name
      * @returns Event
      */
-    get<T = any>(event: string): Event<T>;
+    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(name: string, handler: EventHandler, once?: boolean): 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
@@ -42,8 +43,8 @@ export declare class EventCollection {
      * @param handler Specific handler to remove. If left blank, all handlers in name will be removed
      * @returns this
      */
-    clear(name?: string | "all", handler?: EventHandler): this;
-    emit(name: string, ...args: any[]): any[];
+    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
@@ -51,6 +52,6 @@ export declare class EventCollection {
      *
      * @throws Unknown event, if event name isn't recognized
      */
-    limit(event: 'all' | string, limit: number): this;
+    limit<Event extends keyof Events>(eventName: 'all' | Event, limit: number): this | undefined;
 }
 export default EventCollection;

package/dist/Classes/{EventCollection.js → Events/EventCollection.js}

@@ -1,17 +1,21 @@
 "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 = require("./Event");
+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());
+            events.array().reduce((result, [event, handlers]) => result.set(event, new Event_1.default(event, handlers)), new Map());
     }
     /**Amount of events stored*/
     get size() {
@@ -47,11 +51,8 @@ class EventCollection {
         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);
-        if (once)
-            this._events.set(name, event ? event.once(handler) : new Event_1.default(name).once(handler));
-        else
-            this._events.set(name, event ? event.on(handler) : new Event_1.default(name, handler));
+        const event = (this.has(name) && this.get(name)) || new Event_1.default(name);
+        this._events.set(name, event.on(handler, once));
         return this;
     }
     /**
@@ -65,27 +66,22 @@ class EventCollection {
      * @returns this
      */
     clear(name = 'all', handler) {
-        //clear(): Clears all events
-        if (name.toLowerCase() == 'all' && handler == null)
-            this._events.clear();
-        //clear("all", myEventHandler): Removes the "myEventHandler" handler from all events
-        else if (name.toLowerCase() == '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 = (() => {
-                const eventNames = this._events.array().map(([name, event]) => event.includes(handler) && name);
-                this._events.forEach((event, name) => eventNames.includes(name) &&
-                    this._events.set(name, event.off(handler)));
+                this._events.forEach(e => e.off(handler));
                 return this._events;
             })();
-        //clear("myEvent"): Deletes myEvent from this._events
-        else if (name.toLowerCase() != "all" && handler == null)
-            this._events.delete(name);
-        //clear("myEvent", myEventHandler): Removes the "myEventsHandler" handler from "myEvent"
-        else if (name.toLowerCase() != 'all' && handler)
-            this._events.set(name, this.get(name).off(handler));
+        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);
+        return this.get(name)?.emit(...args);
     }
     /**
      * Limits how many events to accept using EventEmitter#on or EventEmitter#once
@@ -94,15 +90,18 @@ class EventCollection {
      *
      * @throws Unknown event, if event name isn't recognized
      */
-    limit(event, limit) {
+    limit(eventName, limit) {
         if (limit <= 0)
             return;
-        if (event == 'all')
+        if (eventName == 'all') {
             this._limit = limit;
-        else if (this.has(event))
-            this.get(event).limit = limit;
-        else
-            throw new Error(`Unknown event, ${event}!`);
+            return this;
+        }
+        const event = this.get(eventName);
+        if (!event)
+            throw new Error(`Unknown event, ${eventName}!`);
+        event.limit = limit;
+        this._events.set(eventName, event);
         return this;
     }
 }