danholibraryjs 1.6.0 → 1.7.0

package/dist/Extensions.d.ts

@@ -1,96 +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;
-        /**
-         * Returns a random element from array
-         */
-        random(): T;
-        /**
-         * Returns item matching index. If negative number, subtracts number from length
-         * @param i Index of item
-         */
-        index(i: number): T;
-    }
-    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;
-        /**
-         * String.substring but accepting negative numbers to cut from length
-         * @param start Start of string. 0 indexed
-         * @param end End of string. 0 indexed, if negative number, substracts number from length
-         */
-        clip(start: number, end?: number): string;
-    }
-}

package/dist/Extensions.js

@@ -1,90 +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(...[].concat(options.children));
-    }
-    if (options.events) {
-        options.events.forEach(({ name, 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;
-};
-Array.prototype.random = function () {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-};
-Array.prototype.index = function (i) {
-    return this[i < 0 ? this.length + i : i];
-};
-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);
-};
-String.prototype.clip = function (start, end) {
-    return this.substring(start, end < 0 ? this.length + end : end);
-};

package/dist/Interfaces/BaseEventInterface.d.ts

@@ -1,7 +0,0 @@
-/**
- * Default eventhandler mapper. EventEmitter.on(keyof this, this[keyof this])
- */
-export interface BaseEvent {
-    error: [err: Error];
-}
-export default BaseEvent;

package/dist/Interfaces/IHTMLEvent.d.ts

@@ -1,4 +0,0 @@
-export default interface IHTMLEvent<E extends keyof HTMLElementEventMap> {
-    name: E;
-    handler: (e: HTMLElementEventMap[E]) => any;
-}

package/dist/Types/EventHandler.d.ts

@@ -1,8 +0,0 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-/**
- * Eventhandler type for:
- * @see EventCollection
- * @borrows BaseEvent
- */
-export declare type EventHandler<Events extends BaseEvent, Event extends keyof Events, ReturnType = any> = (args: Events[Event]) => 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 @@
-export declare type StringRegex = string | RegExp;
-export default StringRegex;

package/src/Classes/EventCollection.ts

@@ -1,117 +0,0 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-import EventHandler from "../Types/EventHandler";
-import Event from './Event';
-
-/**
- * Collection of Events from @see EventEmitter
- * @borrows EventHandler
- * @borrows Event
- * @borrows BaseEvent
- */
- export class EventCollection<Events extends BaseEvent> {
-    constructor(events?: Map<keyof Events, EventHandler<Events, keyof 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(event: keyof Events): boolean { 
-        return this._events.has(event); 
-    }
-    /**
-     * Returns event matching event parameter
-     * @param event Event name
-     * @returns Event
-     */
-    public get(event: keyof Events): Event<Events> { 
-        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: keyof Events, 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!`);
-        }
-
-        const event = this.has(name) && this.get(name);
-
-        if (once) this._events.set(name, event ? event.once(handler) : new Event<Events>(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: keyof Events | "all" = 'all', handler?: EventHandler<Events, keyof Events>): this {
-        //clear(): Clears all events
-        if ((name as string).toLowerCase() == 'all' && handler == null) this._events.clear();           
-
-        //clear("all", myEventHandler): Removes the "myEventHandler" handler from all events
-        else if ((name as string).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 as string).toLowerCase() != "all" && handler == null) this._events.delete(name as keyof Events);
-
-         //clear("myEvent", myEventHandler): Removes the "myEventsHandler" handler from "myEvent"
-        else if ((name as string).toLowerCase() != 'all' && handler) this._events.set(name as keyof Events, this.get(name as keyof Events).off(handler));
-        
-        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>(event: 'all' | Event, 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,202 +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
-        /**
-         * Returns a random element from array
-         */
-        random(): T
-        /**
-         * Returns item matching index. If negative number, subtracts number from length
-         * @param i Index of item
-         */
-        index(i: number): T
-
-    }
-    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,
-        /**
-         * String.substring but accepting negative numbers to cut from length
-         * @param start Start of string. 0 indexed
-         * @param end End of string. 0 indexed, if negative number, substracts number from length
-         */
-        clip(start: number, end?: number): 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(...[].concat(options.children));
-    }
-
-    if (options.events) {
-        options.events.forEach(({ name, 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;
-}
-Array.prototype.random = function<T>(this: Array<T>): T {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-}
-Array.prototype.index = function<T>(this: Array<T>, i: number): T {
-    return this[i < 0 ? this.length + i : i];
-}
-
-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);
-}
-String.prototype.clip = function(this: string, start: number, end?: number) {
-    return this.substring(start, end < 0 ? this.length + end : end);
-}

package/src/Interfaces/BaseEventInterface.ts

@@ -1,7 +0,0 @@
-/**
- * Default eventhandler mapper. EventEmitter.on(keyof this, this[keyof this])
- */
-export interface BaseEvent {
-    error: [err: Error]
-}
-export default BaseEvent;

package/src/Types/EventHandler.ts

@@ -1,13 +0,0 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-
-/**
- * Eventhandler type for:
- * @see EventCollection
- * @borrows BaseEvent
- */
-export type EventHandler<
-    Events extends BaseEvent, 
-    Event extends keyof Events,
-    ReturnType = any
-> = (args: Events[Event]) => 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 @@
-export type StringRegex = string | RegExp;
-export default StringRegex;

package/test.js

@@ -1,20 +0,0 @@
-const library = require('./dist');
-
-const testElement = document.createProperElement('div', {
-    classes: ['test-elements'],
-    attributes: [],
-    children: [
-        document.createProperElement('h1', { children: 'Hello there' }),
-        document.createProperElement('label', {
-            children: [
-                'Test Element',
-                document.createProperElement('input', {
-                    attributes: [['type', 'test'], ['placeholder', 'Test me here maybe? uwu']]
-                })
-            ]
-        }),
-        document.createProperElement('button', {
-            events: [library.HTMLEvent('click', e => console.log('clicked!'))]
-        })
-    ]
-})