danholibraryjs 1.3.0 → 1.7.0

package/dist/Extensions.d.ts

@@ -1,81 +0,0 @@
-import ElementOptions from "./Interfaces/ElementOptions";
-import IReplacement from "./Interfaces/IReplacement";
-declare global {
-    interface 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): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
-    interface 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 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>;
-        /**
-         * Returns array of keys
-         */
-        keyArr(): Array<K>;
-        /**
-         * Returns 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. Returns true if it does, false if not ¯\_(ツ)_/¯
-         * @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;
-    }
-}

package/dist/Extensions.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-Document.prototype.createProperElement = function (tagName, options) {
-    let baseElement = document.createElement(tagName);
-    if (!options)
-        return baseElement;
-    if (options.classes) {
-        baseElement.classList.add(...options.classes);
-    }
-    if (options.attributes) {
-        options.attributes.forEach(([attribute, value]) => baseElement.setAttribute(attribute, value));
-    }
-    if (options.children) {
-        baseElement.append(...options.children);
-    }
-    if (options.events) {
-        options.events.forEach(({ name, handlers }) => (handlers.forEach(handler => (baseElement.addEventListener(name, handler)))));
-    }
-    return baseElement;
-};
-HTMLCollection.prototype.array = function () {
-    let result = new Array();
-    for (let i = 0; i < this.length; i++) {
-        result.push(this.item(i));
-    }
-    return result;
-};
-Array.prototype.add = function (...items) {
-    this.push(...items);
-    return this;
-};
-Array.prototype.remove = function (item) {
-    const itemInArray = this.includes(item) ? item : this.find(i => i == item);
-    if (!itemInArray)
-        throw new Error(`item is not in array!`);
-    const itemIndex = this.indexOf(itemInArray);
-    this.splice(itemIndex, 1);
-    return this;
-};
-Map.prototype.array = function () {
-    let result = new Array();
-    for (const kvp of this) {
-        result.push(kvp);
-    }
-    return result;
-};
-Map.prototype.map = function (callback) {
-    return this.array()
-        .map(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => map.set(key, value), new Map());
-};
-Map.prototype.filter = function (callback) {
-    return this.array()
-        .filter(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => map.set(key, value), new Map());
-};
-Map.prototype.keyArr = function () {
-    return this.array().map(([k]) => k);
-};
-Map.prototype.valueArr = function () {
-    return this.array().map(([_, v]) => v);
-};
-Map.prototype.find = function (callback) {
-    return this.array().find(([k, v], i) => callback(v, k, i, this));
-};
-Map.prototype.includes = function (item, fromIndex) {
-    return this.valueArr().includes(item, fromIndex);
-};
-String.prototype.toPascalCase = function () {
-    return this.substring(0, 1).toUpperCase() + this.substring(1);
-};
-function spaceReplacer(self, replacer, replacement) {
-    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
-}
-String.prototype.toSnakeCase = function (replaceOptions = { replacer: ' ', replacement: '_' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement);
-};
-String.prototype.toKebabCase = function (replaceOptions = { replacer: ' ', replacement: '-' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement);
-};

package/dist/Types/EventHandler.d.ts

@@ -1,6 +0,0 @@
-/**
- * Eventhandler type for:
- * @see EventCollection
- */
-export declare type EventHandler<ReturnType = any> = (...args: any[]) => ReturnType;
-export default EventHandler;

package/dist/Types/IElement.d.ts

@@ -1,9 +0,0 @@
-/**
- * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
- * IElement accepts HTML Elements or HTMl-like strings.
- *
- * @see HTMLElement.append
- * @see Document.createProperElement
- */
-export declare type IElement = HTMLElement | string;
-export default IElement;

package/dist/Types/StringRegex.d.ts

@@ -1,2 +0,0 @@
-declare type StringRegex = string | RegExp;
-export default StringRegex;

package/src/Classes/EventCollection.ts

@@ -1,115 +0,0 @@
-import EventHandler from "../Types/EventHandler";
-import Event from './Event';
-
-/**
- * Collection of Events from @see EventEmitter
- * @borrows EventHandler
- * @borrows Event
- */
- export class EventCollection {
-    constructor(events?: Map<string, EventHandler[]>) {
-        this._events = !events ? 
-            new Map<string, Event>() : 
-            events.array().reduce((result, [event, handlers]) => 
-                result.set(event, new Event(event, ...handlers)), 
-            new Map<string, Event>());
-    }
-
-    /**Amount of events stored*/
-    public get size() {
-        return this._events.size;
-    }
-    /**@private Internal event collection*/
-    private _events = new Map<string, Event>();
-    /**@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(event: string): boolean { 
-        return this._events.has(event); 
-    }
-    /**
-     * Returns event matching event parameter
-     * @param event Event name
-     * @returns Event
-     */
-    public get<T = any>(event: string): Event<T> { 
-        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
-     */
-    public add(name: string, handler: EventHandler, once = false): this {
-        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(name).once(handler))
-        else this._events.set(name, event ? event.on(handler) : new Event(name, handler));
-        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(name: string | "all" = 'all', handler?: EventHandler): this {
-        //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) 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)
-            ));
-
-            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));
-        
-        return this;
-    }
-
-    public emit(name: string, ...args: any[]) {
-        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: 'all' | string, limit: number) {
-        if (limit <= 0) return;
-
-        if (event == 'all') this._limit = limit;
-        else if (this.has(event)) this.get(event).limit = limit;
-        else throw new Error(`Unknown event, ${event}!`);
-
-        return this;
-    }
-}
-export default EventCollection;

package/src/Extensions.ts

@@ -1,179 +0,0 @@
-import ElementOptions from "./Interfaces/ElementOptions";
-import IReplacement from "./Interfaces/IReplacement";
-
-declare global {
-    interface 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): HTMLElementTagNameMap[K]
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[]
-    }
-    interface 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 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>
-        /**
-         * Returns array of keys
-         */
-        keyArr(): Array<K>
-        /**
-         * Returns 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. Returns true if it does, false if not ¯\_(ツ)_/¯ 
-         * @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
-    }
-}
-
-Document.prototype.createProperElement = function<K extends keyof HTMLElementTagNameMap>(this: Document, tagName: K, options?: ElementOptions) {
-    let baseElement = document.createElement(tagName);
-    if (!options) return baseElement;
-
-    if (options.classes) {
-        baseElement.classList.add(...options.classes);
-    }
-    
-    if (options.attributes) {
-        options.attributes.forEach(([attribute, value]) => baseElement.setAttribute(attribute, value));
-    }
-
-    if (options.children) {
-        baseElement.append(...options.children);
-    }
-
-    if (options.events) {
-        options.events.forEach(({ name, handlers }) => (
-            handlers.forEach(handler => (
-                baseElement.addEventListener(name, handler)
-            ))
-        ))
-    }
-
-    return baseElement;
-}
-
-HTMLCollection.prototype.array = function(this: HTMLCollection) {
-    let result = new Array<Element>();
-
-    for (let i = 0; i < this.length; i++) {
-        result.push(this.item(i));
-    }
-    return result;
-}
-
-Array.prototype.add = function<T>(this: Array<T>, ...items: Array<T>) {
-    this.push(...items);
-    return this;
-}
-Array.prototype.remove = function<T>(this: Array<T>, item: T): Array<T> {
-    const itemInArray = this.includes(item) ? item : this.find(i => i == item);
-    if (!itemInArray) throw new Error(`item is not in array!`);
-    
-    const itemIndex = this.indexOf(itemInArray);
-    this.splice(itemIndex, 1);
-    return this;
-}
-
-Map.prototype.array = function<K, V>(this: Map<K, V>): [K, V][] {
-    let result = new Array<[K, V]>();
-    for (const kvp of this) {
-        result.push(kvp);
-    }
-    return result;
-}
-Map.prototype.map = function<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => [EK, EV]): Map<EK, EV> {
-    return this.array()
-        .map(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => 
-            map.set(key, value), 
-        new Map<EK, EV>())
-}
-Map.prototype.filter = function<K, V>(this: Map<K, V>, callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): Map<K, V> {
-    return this.array()
-        .filter(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => 
-            map.set(key, value), 
-        new Map<K, V>())
-}
-Map.prototype.keyArr = function<K, V>(this: Map<K, V>): K[] {
-    return this.array().map(([k]) => k);
-}
-Map.prototype.valueArr = function<K, V>(this: Map<K, V>): V[] {
-    return this.array().map(([_, v]) => v);
-}
-Map.prototype.find = function<K, V>(this: Map<K, V>, callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean) {
-    return this.array().find(([k, v], i) => callback(v, k, i, this));
-}
-Map.prototype.includes = function<K, V>(this: Map<K, V>, item: V, fromIndex?: number) {
-    return this.valueArr().includes(item, fromIndex);
-}
-
-String.prototype.toPascalCase = function(this: string) {
-    return this.substring(0, 1).toUpperCase() + this.substring(1);
-}
-
-function spaceReplacer(self: string, replacer: string | RegExp, replacement: string) {
-    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
-}
-String.prototype.toSnakeCase = function(this: string, replaceOptions: IReplacement = { replacer: ' ', replacement: '_' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement)
-}
-String.prototype.toKebabCase = function(this: string, replaceOptions: IReplacement = { replacer: ' ', replacement: '-' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement);
-}

package/src/Types/EventHandler.ts

@@ -1,6 +0,0 @@
-/**
- * Eventhandler type for:
- * @see EventCollection
- */
-export type EventHandler<ReturnType = any> = (...args: any[]) => ReturnType;
-export default EventHandler;

package/src/Types/IElement.ts

@@ -1,9 +0,0 @@
-/**
- * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
- * IElement accepts HTML Elements or HTMl-like strings.
- * 
- * @see HTMLElement.append
- * @see Document.createProperElement
- */
-export type IElement = HTMLElement | string;
-export default IElement

package/src/Types/StringRegex.ts

@@ -1,2 +0,0 @@
-type StringRegex = string | RegExp;
-export default StringRegex;