danholibraryjs 1.11.0 → 2.0.0

package/dist/Extensions/Array.d.ts

@@ -1,52 +1,52 @@
-export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
-declare global {
-    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;
-        /**
-         * Update an item in array
-         * @param old The old value or index to update
-         * @param updated Updated value
-         */
-        update(old: T | number | UpdateFinder<T>, updated: T): T;
-        /**
-         * Removes item from array and returns self without item
-         * @param item Item or index to remove
-         */
-        remove(item: T | number): 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;
-        /**
-         * For every x in array, execute callback
-         * @param every i.e every 2nd item in array
-         * @param callback Function to execute
-         * @returns Array of results
-         */
-        nth<U>(every: number, callback: (item: T, index: number, collection: Array<T>, self: this) => U): Array<U>;
-    }
-}
-declare function add<T>(this: Array<T>, ...items: Array<T>): T[];
-declare function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T): T;
-declare function remove<T>(this: Array<T>, value: T | number): Array<T>;
-declare function random<T>(this: Array<T>): T;
-declare function index<T>(this: Array<T>, i: number): T;
-declare function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U>;
-export declare const ArrayExtensions: {
-    add: typeof add;
-    update: typeof update;
-    remove: typeof remove;
-    random: typeof random;
-    index: typeof index;
-    nth: typeof nth;
-};
-export {};
+export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
+declare global {
+    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;
+        /**
+         * Update an item in array
+         * @param old The old value or index to update
+         * @param updated Updated value
+         */
+        update(old: T | number | UpdateFinder<T>, updated: T): T;
+        /**
+         * Removes item from array and returns self without item
+         * @param item Item or index to remove
+         */
+        remove(item: T | number): 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;
+        /**
+         * For every x in array, execute callback
+         * @param every i.e every 2nd item in array
+         * @param callback Function to execute
+         * @returns Array of results
+         */
+        nth<U>(every: number, callback: (item: T, index: number, collection: Array<T>, self: this) => U): Array<U>;
+    }
+}
+declare function add<T>(this: Array<T>, ...items: Array<T>): T[];
+declare function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T): T;
+declare function remove<T>(this: Array<T>, value: T | number): Array<T>;
+declare function random<T>(this: Array<T>): T;
+declare function index<T>(this: Array<T>, i: number): T;
+declare function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U>;
+export declare const ArrayExtensions: {
+    add: typeof add;
+    update: typeof update;
+    remove: typeof remove;
+    random: typeof random;
+    index: typeof index;
+    nth: typeof nth;
+};
+export {};

package/dist/Extensions/Array.js

@@ -1,51 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = void 0;
-function add(...items) {
-    this.push(...items);
-    return this;
-}
-Array.prototype.add = add;
-function update(old, updated) {
-    const item = typeof old === 'number' ? this[old]
-        : typeof old === 'function' ? this.find(old)
-            : old;
-    if (!item)
-        throw new Error('Old was not found in array!');
-    const index = this.indexOf(item);
-    return this[index] = updated;
-}
-Array.prototype.update = update;
-function remove(value) {
-    const index = typeof value === 'number' ? value : this.indexOf(value);
-    if (index > -1)
-        this.splice(index, 1);
-    return this;
-}
-Array.prototype.remove = remove;
-function random() {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-}
-Array.prototype.random = random;
-function index(i) {
-    return this[i < 0 ? this.length + i : i];
-}
-Array.prototype.index = index;
-function nth(every, callback) {
-    const result = new Array();
-    let collection = new Array();
-    for (let i = 0; i < this.length; i++) {
-        collection.push(this[i]);
-        if (i % every === 0) {
-            result.push(callback(this[i], i, collection, this));
-            collection = new Array();
-        }
-    }
-    return result;
-}
-Array.prototype.nth = nth;
-exports.ArrayExtensions = {
-    add, update, remove,
-    random, index, nth
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayExtensions = void 0;
+function add(...items) {
+    this.push(...items);
+    return this;
+}
+Array.prototype.add = add;
+function update(old, updated) {
+    const item = typeof old === 'number' ? this[old]
+        : typeof old === 'function' ? this.find(old)
+            : old;
+    if (!item)
+        throw new Error('Old was not found in array!');
+    const index = this.indexOf(item);
+    return this[index] = updated;
+}
+Array.prototype.update = update;
+function remove(value) {
+    const index = typeof value === 'number' ? value : this.indexOf(value);
+    if (index > -1)
+        this.splice(index, 1);
+    return this;
+}
+Array.prototype.remove = remove;
+function random() {
+    const randomIndex = Math.round(Math.random() * this.length);
+    return this[randomIndex];
+}
+Array.prototype.random = random;
+function index(i) {
+    return this[i < 0 ? this.length + i : i];
+}
+Array.prototype.index = index;
+function nth(every, callback) {
+    const result = new Array();
+    let collection = new Array();
+    for (let i = 0; i < this.length; i++) {
+        collection.push(this[i]);
+        if (i % every === 0) {
+            result.push(callback(this[i], i, collection, this));
+            collection = new Array();
+        }
+    }
+    return result;
+}
+Array.prototype.nth = nth;
+exports.ArrayExtensions = {
+    add, update, remove,
+    random, index, nth
+};

package/dist/Extensions/Document.d.ts

@@ -1,27 +1,27 @@
-import { IElement } from "../Types";
-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
-         * @param children Child elements
-         */
-        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]>, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-        createElementFromString<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
-}
-declare function createElement<Tag extends keyof HTMLElementTagNameMap>(this: Document, tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]> | string, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-declare function createElementFromString<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag];
-export declare const DocumentExtensions: {
-    createElement: typeof createElement;
-    createElementFromString: typeof createElementFromString;
-};
-export {};
+import { IElement } from "../Types";
+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
+         * @param children Child elements
+         */
+        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]>, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+        createElementFromString<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
+    }
+    interface HTMLCollection {
+        /**
+         * Converts HTMLCollection to Element[]
+         */
+        array(): Element[];
+    }
+}
+declare function createElement<Tag extends keyof HTMLElementTagNameMap>(this: Document, tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]> | string, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+declare function createElementFromString<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag];
+export declare const DocumentExtensions: {
+    createElement: typeof createElement;
+    createElementFromString: typeof createElementFromString;
+};
+export {};

package/dist/Extensions/Document.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentExtensions = void 0;
-function createElement(tagName, options, ...children) {
-    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
-    children ??= typeof options === 'string' ? [options] : [];
-    typeof options === 'string' && children.unshift(options);
-    if (!children.length)
-        return element;
-    else if (typeof children === 'string')
-        element.innerHTML = children;
-    else if (children instanceof Array)
-        children.forEach(child => (typeof child === 'string' ?
-            element.innerHTML += child :
-            element.appendChild(child)));
-    else
-        element.appendChild(children);
-    return element;
-}
-Document.prototype.createProperElement = createElement;
-function createElementFromString(html, tag) {
-    if (!html.startsWith(`<${tag}`))
-        html = `<${tag}>${html}</${tag}>`;
-    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild;
-}
-Document.prototype.createElementFromString = createElementFromString;
-HTMLCollection.prototype.array = function () {
-    return Array.from(this);
-};
-exports.DocumentExtensions = {
-    createElement, createElementFromString
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentExtensions = void 0;
+function createElement(tagName, options, ...children) {
+    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
+    children ??= typeof options === 'string' ? [options] : [];
+    typeof options === 'string' && children.unshift(options);
+    if (!children.length)
+        return element;
+    else if (typeof children === 'string')
+        element.innerHTML = children;
+    else if (children instanceof Array)
+        children.forEach(child => (typeof child === 'string' ?
+            element.innerHTML += child :
+            element.appendChild(child)));
+    else
+        element.appendChild(children);
+    return element;
+}
+Document.prototype.createProperElement = createElement;
+function createElementFromString(html, tag) {
+    if (!html.startsWith(`<${tag}`))
+        html = `<${tag}>${html}</${tag}>`;
+    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild;
+}
+Document.prototype.createElementFromString = createElementFromString;
+HTMLCollection.prototype.array = function () {
+    return Array.from(this);
+};
+exports.DocumentExtensions = {
+    createElement, createElementFromString
+};

package/dist/Extensions/Function.d.ts

@@ -1,14 +1,29 @@
-declare global {
-    interface Function {
-        /**
-         * Checks if obj is a function
-         * @param obj Object to check
-         */
-        is(obj: any): obj is Function;
-    }
-}
-declare function is(obj: any): obj is Function;
-export declare const FunctionExtensions: {
-    is: typeof is;
-};
-export {};
+import { Functionable } from "../Types";
+declare global {
+    interface Function {
+        /**
+         * Checks if obj is a function
+         * @param obj Object to check
+         */
+        is(obj: any): obj is Function;
+        /**
+         * Resolves a Functionable<T> to T, if it's a function, it will be called with the provided arguments and its return value will be returned, otherwise the value itself will be returned.
+         * @param functionable The Functionable<T> to resolve
+         * @param args Arguments to call the function with if functionable is a function
+         */
+        resolveFunctionable<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>, ...args: TArgs): T;
+        /**
+         * Forces a Functionable<T> to be a function, if it's already a function, it will be returned as is, otherwise a function that returns the value will be returned.
+         * @param functionable The Functionable<T> to force to be a function
+         */
+        forceFunction<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>): (...args: TArgs) => T;
+    }
+}
+export declare function is(obj: any): obj is Function;
+export declare function resolveFunctionable<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>, ...args: TArgs): T;
+export declare function forceFunction<T, TArgs extends any[] = any[]>(functionable: Functionable<T, TArgs>): (...args: TArgs) => T;
+export declare const FunctionExtensions: {
+    is: typeof is;
+    resolveFunctionable: typeof resolveFunctionable;
+    forceFunction: typeof forceFunction;
+};

package/dist/Extensions/Function.js

@@ -1,10 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionExtensions = void 0;
-function is(obj) {
-    return typeof obj === 'function';
-}
-Function.is = is;
-exports.FunctionExtensions = {
-    is
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionExtensions = exports.forceFunction = exports.resolveFunctionable = exports.is = void 0;
+function is(obj) {
+    return typeof obj === 'function';
+}
+exports.is = is;
+Function.is = is;
+function resolveFunctionable(functionable, ...args) {
+    return is(functionable) ? functionable(...args) : functionable;
+}
+exports.resolveFunctionable = resolveFunctionable;
+Function.resolveFunctionable = resolveFunctionable;
+function forceFunction(functionable) {
+    return is(functionable) ? functionable : () => functionable;
+}
+exports.forceFunction = forceFunction;
+Function.forceFunction = forceFunction;
+exports.FunctionExtensions = {
+    is,
+    resolveFunctionable,
+    forceFunction
+};

package/dist/Extensions/Map.d.ts

@@ -1,54 +1,54 @@
-declare global {
-    interface Map<K, V> {
-        /**
-         * Converts into Array<[Key, Value]>
-         */
-        array(): 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, self: 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, self: this) => 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. Returns undefined if nothing found
-         * @param callback Callbacking function to find KeyValuePair
-         */
-        find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined;
-        /**
-         * 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;
-    }
-}
-declare function array<K, V>(this: Map<K, V>): Array<[K, V]>;
-declare function map<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV>;
-declare function filter<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V>;
-declare function keyArr<K, V>(this: Map<K, V>): Array<K>;
-declare function valueArr<K, V>(this: Map<K, V>): Array<V>;
-declare function find<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): [K, V] | undefined;
-declare function includes<K, V>(this: Map<K, V>, item: V, fromIndex?: number): boolean;
-export declare const MapExtensions: {
-    array: typeof array;
-    map: typeof map;
-    filter: typeof filter;
-    keyArr: typeof keyArr;
-    valueArr: typeof valueArr;
-    find: typeof find;
-    includes: typeof includes;
-};
-export {};
+declare global {
+    interface Map<K, V> {
+        /**
+         * Converts into Array<[Key, Value]>
+         */
+        array(): 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, self: 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, self: this) => 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. Returns undefined if nothing found
+         * @param callback Callbacking function to find KeyValuePair
+         */
+        find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined;
+        /**
+         * 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;
+    }
+}
+declare function array<K, V>(this: Map<K, V>): Array<[K, V]>;
+declare function map<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV>;
+declare function filter<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V>;
+declare function keyArr<K, V>(this: Map<K, V>): Array<K>;
+declare function valueArr<K, V>(this: Map<K, V>): Array<V>;
+declare function find<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): [K, V] | undefined;
+declare function includes<K, V>(this: Map<K, V>, item: V, fromIndex?: number): boolean;
+export declare const MapExtensions: {
+    array: typeof array;
+    map: typeof map;
+    filter: typeof filter;
+    keyArr: typeof keyArr;
+    valueArr: typeof valueArr;
+    find: typeof find;
+    includes: typeof includes;
+};
+export {};

package/dist/Extensions/Map.js

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapExtensions = void 0;
-function array() {
-    let result = new Array();
-    for (const kvp of this) {
-        result.push(kvp);
-    }
-    return result;
-}
-Map.prototype.array = array;
-function map(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.map = map;
-function filter(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.filter = filter;
-function keyArr() {
-    return this.array().map(([k]) => k);
-}
-Map.prototype.keyArr = keyArr;
-function valueArr() {
-    return this.array().map(([_, v]) => v);
-}
-Map.prototype.valueArr = valueArr;
-function find(callback) {
-    return this.array().find(([k, v], i) => callback(v, k, i, this));
-}
-Map.prototype.find = find;
-function includes(item, fromIndex) {
-    return this.valueArr().includes(item, fromIndex);
-}
-Map.prototype.includes = includes;
-exports.MapExtensions = {
-    array, map, filter, keyArr, valueArr, find, includes
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapExtensions = void 0;
+function array() {
+    let result = new Array();
+    for (const kvp of this) {
+        result.push(kvp);
+    }
+    return result;
+}
+Map.prototype.array = array;
+function map(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.map = map;
+function filter(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.filter = filter;
+function keyArr() {
+    return this.array().map(([k]) => k);
+}
+Map.prototype.keyArr = keyArr;
+function valueArr() {
+    return this.array().map(([_, v]) => v);
+}
+Map.prototype.valueArr = valueArr;
+function find(callback) {
+    return this.array().find(([k, v], i) => callback(v, k, i, this));
+}
+Map.prototype.find = find;
+function includes(item, fromIndex) {
+    return this.valueArr().includes(item, fromIndex);
+}
+Map.prototype.includes = includes;
+exports.MapExtensions = {
+    array, map, filter, keyArr, valueArr, find, includes
+};

package/dist/Extensions/Number.d.ts

@@ -0,0 +1,13 @@
+type Separators = {
+    thousand: string;
+    decimal: string;
+};
+declare global {
+    interface Number {
+        toSeparationString(separators: Partial<Separators>): string;
+        toRomanNumeral(): string;
+    }
+}
+export declare function toSeparationString(this: number, separators: Partial<Separators>): string;
+export declare function toRomanNumeral(this: number): string;
+export {};

package/dist/Extensions/Number.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRomanNumeral = exports.toSeparationString = void 0;
+function toSeparationString(separators) {
+    const { thousand = '.', decimal = '.' } = separators;
+    const [integerPart, decimalPart] = this.toString().split('.');
+    const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousand);
+    return decimalPart ? `${formattedInteger}${decimal}${decimalPart}` : formattedInteger;
+}
+exports.toSeparationString = toSeparationString;
+Number.prototype.toSeparationString = toSeparationString;
+function toRomanNumeral() {
+    if (this <= 0 || this >= 4000)
+        throw new RangeError('Number must be between 1 and 3999 to convert to Roman numeral');
+    const numeralMap = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I']
+    ];
+    let value = this;
+    return numeralMap.reduce((acc, [numeralValue, numeral]) => {
+        while (value >= numeralValue) {
+            acc += numeral;
+            value -= numeralValue;
+        }
+        return acc;
+    }, '');
+}
+exports.toRomanNumeral = toRomanNumeral;
+Number.prototype.toRomanNumeral = toRomanNumeral;