danholibraryjs 1.3.0 → 1.7.0

package/dist/Classes/Time/TimeSpan.d.ts

@@ -0,0 +1,123 @@
+import { TransformType } from "../../Types";
+import DanhoDate, { DanhoDateConstructor } from "./Date";
+import TimeProperties from "./TimeProperties";
+/**
+ * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
+ */
+export declare type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
+/**
+ * Timespan between 2 dates.
+ * @borrows TimeSpanValue
+ * @borrows Time
+ * @borrows TimeProperties
+ */
+export declare class TimeSpan implements TimeProperties<true> {
+    constructor(from: DanhoDateConstructor, to?: DanhoDateConstructor);
+    /**
+     * Which of the dates in constructor had the highest getTime()
+     */
+    private _highest;
+    /**
+     * Which of the dates in constructor had the lowest getTime()
+     */
+    private _lowest;
+    /**
+     * The time difference between highest and lowest
+     * @returns Time difference in ms between this._highest and this._lowest
+     */
+    private _getTimeDifference;
+    /**
+     * Reduces ms into provided timeDifference
+     * @param ms Millisecond value to reduce
+     * @param timeDifference Time difference in ms that for each timeDifference in ms, add 1 to result
+     * @returns How many times timeDifference fits in ms
+     */
+    private _reduceTime;
+    /**
+     * Total years between dates
+     */
+    years: number;
+    /**
+     * Total months between dates
+     */
+    months: number;
+    /**
+     * Total weeks between dates
+     */
+    weeks: number;
+    /**
+     * Total days between dates
+     */
+    days: number;
+    /**
+     * Total hours between dates
+     */
+    hours: number;
+    /**
+     * Total minutes between dates
+     */
+    minutes: number;
+    /**
+     * Total seconds between dates
+     */
+    seconds: number;
+    /**
+     * Total milliseconds between dates
+     */
+    milliseconds: number;
+    /**
+     * Get the total unit time between the two dates
+     * @param unit Time unit in milliseconds
+     * @returns How many times that unit fits in total ms between the two dates
+     */
+    private _getTotalUnit;
+    /**
+     * Get the maximum amount of months between the two dates
+     * @returns Number of max amount of months that are between the two dates
+     */
+    getTotalMonths(): number;
+    /**
+     * Get the maximum amount of weeks between the two dates
+     * @returns Number of max amount of weeks that are between the two dates
+     */
+    getTotalWeeks(): number;
+    /**
+     * Get the maximum amount of days between the two dates
+     * @returns Number of max amount of days that are between the two dates
+     */
+    getTotalDays(): number;
+    /**
+     * Get the maximum amount of hours between the two dates
+     * @returns Number of max amount of hours that are between the two dates
+     */
+    getTotalHours(): number;
+    /**
+     * Get the maximum amount of minutes between the two dates
+     * @returns Number of max amount of minutes that are between the two dates
+     */
+    getTotalMinutes(): number;
+    /**
+     * Get the maximum amount of seconds between the two dates
+     * @returns Number of max amount of seconds that are between the two dates
+     */
+    getTotalSeconds(): number;
+    /**
+     * Get the maximum amount of milliseconds between the two dates
+     * @returns Number of max amount of milliseconds that are between the two dates
+     */
+    getTotalMilliseconds(): number;
+    /**
+     * Start date of timespan
+     */
+    from: DanhoDate;
+    /**
+     * End date of timespan
+     */
+    to: DanhoDate;
+    /**
+     * Timespan is in the past
+     */
+    pastTense: boolean;
+    toString(format?: TimeSpanFormat): string;
+}
+export default TimeSpan;

package/dist/Classes/Time/TimeSpan.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSpan = void 0;
+const Date_1 = __importDefault(require("./Date"));
+const Time_1 = __importDefault(require("./Time"));
+/**
+ * Timespan between 2 dates.
+ * @borrows TimeSpanValue
+ * @borrows Time
+ * @borrows TimeProperties
+ */
+class TimeSpan {
+    constructor(from, to = Date.now()) {
+        //General properties
+        this.from = new Date_1.default(from);
+        this.to = new Date_1.default(to);
+        //Ensure from < to
+        this._highest = this.from.time > this.to.time ? this.from : this.to;
+        this._lowest = this.from == this._highest ? this.to : this.from;
+        this.pastTense = this._highest !== this.to;
+        this._highest = new Date_1.default(this._highest.time + Time_1.default.millisecond);
+        let timeDifference = this._getTimeDifference();
+        //Calculate time difference between from & to and set to object properties
+        [this.years, timeDifference] = this._reduceTime(Time_1.default.year, timeDifference);
+        [this.months, timeDifference] = this._reduceTime(Time_1.default.month, timeDifference);
+        [this.weeks, timeDifference] = this._reduceTime(Time_1.default.week, timeDifference);
+        [this.days, timeDifference] = this._reduceTime(Time_1.default.day, timeDifference);
+        [this.hours, timeDifference] = this._reduceTime(Time_1.default.hour, timeDifference);
+        [this.minutes, timeDifference] = this._reduceTime(Time_1.default.minute, timeDifference);
+        [this.seconds, timeDifference] = this._reduceTime(Time_1.default.second, timeDifference);
+        [this.milliseconds, timeDifference] = this._reduceTime(Time_1.default.millisecond, timeDifference);
+    }
+    /**
+     * Which of the dates in constructor had the highest getTime()
+     */
+    _highest;
+    /**
+     * Which of the dates in constructor had the lowest getTime()
+     */
+    _lowest;
+    /**
+     * The time difference between highest and lowest
+     * @returns Time difference in ms between this._highest and this._lowest
+     */
+    _getTimeDifference() {
+        return Math.round(this._highest.time - this._lowest.time);
+    }
+    /**
+     * Reduces ms into provided timeDifference
+     * @param ms Millisecond value to reduce
+     * @param timeDifference Time difference in ms that for each timeDifference in ms, add 1 to result
+     * @returns How many times timeDifference fits in ms
+     */
+    _reduceTime(ms, timeDifference) {
+        let result = 0;
+        while (timeDifference > ms) {
+            timeDifference -= ms;
+            result++;
+        }
+        return [result, timeDifference];
+    }
+    /**
+     * Total years between dates
+     */
+    years;
+    /**
+     * Total months between dates
+     */
+    months;
+    /**
+     * Total weeks between dates
+     */
+    weeks;
+    /**
+     * Total days between dates
+     */
+    days;
+    /**
+     * Total hours between dates
+     */
+    hours;
+    /**
+     * Total minutes between dates
+     */
+    minutes;
+    /**
+     * Total seconds between dates
+     */
+    seconds;
+    /**
+     * Total milliseconds between dates
+     */
+    milliseconds;
+    /**
+     * Get the total unit time between the two dates
+     * @param unit Time unit in milliseconds
+     * @returns How many times that unit fits in total ms between the two dates
+     */
+    _getTotalUnit(unit) {
+        return this._reduceTime(unit, this._getTimeDifference())[0];
+    }
+    /**
+     * Get the maximum amount of months between the two dates
+     * @returns Number of max amount of months that are between the two dates
+     */
+    getTotalMonths() {
+        return this._getTotalUnit(Time_1.default.month);
+    }
+    /**
+     * Get the maximum amount of weeks between the two dates
+     * @returns Number of max amount of weeks that are between the two dates
+     */
+    getTotalWeeks() {
+        return this._getTotalUnit(Time_1.default.week);
+    }
+    /**
+     * Get the maximum amount of days between the two dates
+     * @returns Number of max amount of days that are between the two dates
+     */
+    getTotalDays() {
+        return this._getTotalUnit(Time_1.default.day);
+    }
+    /**
+     * Get the maximum amount of hours between the two dates
+     * @returns Number of max amount of hours that are between the two dates
+     */
+    getTotalHours() {
+        return this._getTotalUnit(Time_1.default.hour);
+    }
+    /**
+     * Get the maximum amount of minutes between the two dates
+     * @returns Number of max amount of minutes that are between the two dates
+     */
+    getTotalMinutes() {
+        return this._getTotalUnit(Time_1.default.minute);
+    }
+    /**
+     * Get the maximum amount of seconds between the two dates
+     * @returns Number of max amount of seconds that are between the two dates
+     */
+    getTotalSeconds() {
+        return this._getTotalUnit(Time_1.default.second);
+    }
+    /**
+     * Get the maximum amount of milliseconds between the two dates
+     * @returns Number of max amount of milliseconds that are between the two dates
+     */
+    getTotalMilliseconds() {
+        return this._getTotalUnit(Time_1.default.millisecond);
+    }
+    /**
+     * Start date of timespan
+     */
+    from;
+    /**
+     * End date of timespan
+     */
+    to;
+    /**
+     * Timespan is in the past
+     */
+    pastTense;
+    toString(format) {
+        //console.log(`${this.years}Y ${this.months}M ${this.weeks}w ${this.days}d ${this.hours}h ${this.minutes}m ${this.seconds}s ${this.milliseconds}ms`);
+        const times = [this.years, this.months, this.weeks, this.days, this.hours, this.minutes, this.seconds, this.milliseconds];
+        const timeMsg = ["year", "month", "week", "day", "hour", "minute", "second", "millisecond"];
+        const result = times.reduce((result, time, i) => (
+        // If time is above 0, format is provided, a property matches current property and said property is true, append addition else return result
+        time > 0 && (format ? timeMsg[i] in format && format[timeMsg[i]] === true : true) ?
+            `${result}${times[i]} ${timeMsg[i]}${times[i] != 1 ? 's' : ''}, ` :
+            result), '');
+        return result.length > 2 && result.substring(0, result.length - 2) || '';
+    }
+}
+exports.TimeSpan = TimeSpan;
+exports.default = TimeSpan;

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

@@ -0,0 +1,4 @@
+export * from './Date';
+export * from './Time';
+export * from './TimeProperties';
+export * from './TimeSpan';

package/dist/Classes/Time/index.js

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

package/dist/Classes/index.d.ts

@@ -1,2 +1,2 @@
-export * from './EventEmitter';
-export * from './EventCollection';
+export * from './Events';
+export * from './Time';

package/dist/Classes/index.js

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

package/dist/Extensions/Array.d.ts

@@ -0,0 +1,31 @@
+export {};
+declare 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;
+    }
+}

package/dist/Extensions/Array.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Array.prototype.add = function (...items) {
+    this.push(...items);
+    return this;
+};
+Array.prototype.update = function (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.remove = function (value) {
+    const index = typeof value === 'number' ? value : this.indexOf(value);
+    if (index > -1)
+        this.splice(index, 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];
+};

package/dist/Extensions/Map.d.ts

@@ -0,0 +1,38 @@
+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;
+    }
+}

package/dist/Extensions/Map.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+};

package/dist/Extensions/Object.d.ts

@@ -0,0 +1,16 @@
+import { ValueOf } from "../Types";
+export {};
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Destructures object into array of [property, value]
+         * @param from Object to destruct
+         */
+        array<From = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From = {}>(from: From): Array<keyof From>;
+    }
+}

package/dist/Extensions/Object.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.keysOf = function (from) {
+    return Object.keys(from);
+};
+Object.array = function (from) {
+    return Object.keysOf(from).map(prop => [prop, from[prop]]);
+};

package/dist/Extensions/String.d.ts

@@ -0,0 +1,26 @@
+import IReplacement from "../Interfaces/IReplacement";
+export {};
+declare global {
+    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, if negative number, subtracts number from length
+         * @param end End of string. 0 indexed, if negative number, substracts number from length
+         */
+        clip(start: number, end?: number): string;
+    }
+}

package/dist/Extensions/String.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_');
+};
+String.prototype.toKebabCase = function (replaceOptions) {
+    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
+};
+String.prototype.clip = function (start, end) {
+    return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
+};

package/dist/Extensions/index.d.ts

@@ -0,0 +1,29 @@
+import ElementOptions from "../Interfaces/ElementOptions";
+import { IElement } from "../Types";
+export * from './Array';
+export * from './Map';
+export * from './Object';
+export * from './String';
+declare global {
+    interface BooleanConstructor {
+        /**
+         * Parses string to boolean. Will only return true if value === "true" otherwise false
+         */
+        parseBoolean(value: string): boolean;
+    }
+    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, ...children: Array<IElement>): HTMLElementTagNameMap[K];
+        createFromHtml<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
+    }
+    interface HTMLCollection {
+        /**
+         * Converts HTMLCollection to Element[]
+         */
+        array(): Element[];
+    }
+}

package/dist/Extensions/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Array"), exports);
+__exportStar(require("./Map"), exports);
+__exportStar(require("./Object"), exports);
+__exportStar(require("./String"), exports);
+Boolean.parseBoolean = function (value) {
+    return value === "true";
+};
+try {
+    Document.prototype.createProperElement = function (tagName, options, ...children) {
+        let baseElement = document.createElement(tagName);
+        if (!options)
+            return baseElement;
+        const { id, class: className, dataset, ...rest } = options;
+        if (id)
+            baseElement.id = id;
+        if (className) {
+            const classNames = Array.isArray(className) ? className : [className];
+            classNames.forEach(className => baseElement.classList.add(className));
+        }
+        children ?? options.children;
+        if (children) {
+            const childrenElements = Array.isArray(children) ? children : [children];
+            childrenElements.forEach(child => baseElement.append(child));
+        }
+        if (dataset)
+            Object.entries(dataset).forEach(([key, value]) => baseElement.dataset[key] = value);
+        for (const optionKey in rest) {
+            const optionValue = rest[optionKey];
+            if (optionValue === undefined)
+                continue;
+            if (typeof optionValue === 'function') {
+                baseElement.addEventListener(optionKey.substring(2), rest[optionKey]);
+            }
+            else {
+                baseElement.setAttribute(optionKey, optionValue.toString());
+            }
+        }
+        return baseElement;
+    };
+    Document.prototype.createFromHtml = function (html, parentTag) {
+        return new DOMParser().parseFromString(html, 'text/html').body.firstChild;
+    };
+    HTMLCollection.prototype.array = function () {
+        let result = new Array();
+        for (let i = 0; i < this.length; i++) {
+            const item = this.item(i);
+            if (item !== null)
+                result.push(item);
+        }
+        return result;
+    };
+}
+catch {
+    // Used in node.js
+}

package/dist/Functions/GetCSSProperty.d.ts

@@ -0,0 +1,15 @@
+declare type CSSReturnTypes = {
+    string: string;
+    number: number;
+};
+/**
+ * Gets the value of "property" in type "type" from query "query"
+ * Basically, you can get your --color-primary from :root
+ *
+ * @param property Name of the property to get
+ * @param type Type of the property to parse
+ * @param query Query to get the element that has the property
+ * @returns Property value converted to type
+*/
+export declare function GetCSSProperty<Type extends keyof CSSReturnTypes>(property: string, type: Type, query?: string): CSSReturnTypes[Type];
+export {};