danholibraryjs 1.5.0 → 1.8.0

package/dist/Classes/Time/Time.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Time = exports.ms = exports.ValidTime = void 0;
+exports.ValidTime = /^(\d+(?:\.|,)?\d*)(ms|s|m|h|d|w|M|y)$/;
+/**
+ * Converts input into milliseconds
+ * @param input Input to convert to ms. 1s | 2m | 3h | 1M | 60000
+ * @returns Millisecond value of input
+ */
+function ms(input) {
+    if (typeof input === 'number')
+        return input;
+    const match = input.match(exports.ValidTime);
+    if (!match)
+        throw Error(`Invalid input string "${input}"`);
+    match.shift();
+    const [value, unit] = match;
+    // console.log({ value, unit, input, match });
+    const units = new Map([
+        ['ms', Time.millisecond],
+        ['s', Time.second],
+        ['m', Time.minute],
+        ['h', Time.hour],
+        ['d', Time.day],
+        ['w', Time.week],
+        ['M', Time.month],
+        ['y', Time.year]
+    ]);
+    return parseInt(value) * units.get(unit);
+}
+exports.ms = ms;
+/**
+ * Time utility class
+ * @borrows TimeDelay
+ * @borrows ms
+ */
+class Time {
+    /**
+     * Array of amount of days in the months. 0 indexed
+     */
+    static get daysInMonth() {
+        return [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    }
+    /**
+     * Amount of weeks per year
+     */
+    static get weeksInYear() {
+        return Time.daysInYear * Time.day / Time.week;
+    }
+    /**
+     * Amount of days per year
+     */
+    static get daysInYear() {
+        return Time.year / Time.day;
+        ;
+    }
+    /**
+     * Returns function that converts value into double digit string
+     * @returns (value: number): string
+     */
+    static DoubleDigit(value) {
+        return value.toString().length < 2 ? `0${value}` : value.toString();
+    }
+    static th(value, includeValue = false) {
+        const th = (() => {
+            switch (value) {
+                case 1: return 'st';
+                case 2: return 'nd';
+                case 3: return 'rd';
+                default: return 'th';
+            }
+        })();
+        return includeValue ? value + th : th;
+    }
+    /**
+     * Array of names of the months. 0 idnexed
+     */
+    static get MonthNames() {
+        return new Array('Janurary', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December');
+    }
+    /**
+     * Array of names of the days of the week. 0 indexed
+     */
+    static get DayNames() {
+        return new Array('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday');
+    }
+    /** Millisecond in milliseconds (I know that sounds weird but the others make sense) */
+    static get millisecond() { return 1; }
+    /** Second in milliseconds */
+    static get second() { return Time.millisecond * 1000; }
+    /** Minute in milliseconds */
+    static get minute() { return Time.second * 60; }
+    /** Hour in milliseconds */
+    static get hour() { return Time.minute * 60; }
+    /** Day in milliseconds */
+    static get day() { return Time.hour * 24; }
+    /** Week in milliseconds */
+    static get week() { return Time.day * 7; }
+    /** Month in milliseconds */
+    static get month() {
+        return Time.avgMonth * Time.day;
+    }
+    /** Year in milliseconds */
+    static get year() {
+        const now = new Date();
+        return (365 + (now.getFullYear() % 4 == 0 ? 1 : 0)) * Time.day;
+    }
+    /** Average month in milliseconds */
+    static get avgMonth() {
+        return Math.round(this.daysInMonth.reduce((result, num) => result += num, 0) / 12);
+    }
+    static ms(input) {
+        return ms(input);
+    }
+}
+exports.Time = Time;
+exports.default = Time;

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

@@ -0,0 +1,3 @@
+declare type TimeKeys = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+export declare type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>;
+export default TimeProperties;

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,3 +1,2 @@
-export * from './EventEmitter';
-export * from './EventCollection';
-export * from './Event';
+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,6 +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("./Event"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./Time"), exports);

package/dist/Classes/store.d.ts

@@ -0,0 +1,79 @@
+import { Arrayable } from "../Types";
+import { EventEmitter } from "./Events";
+export declare type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State;
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+export declare class Store<State extends object, ActionTypes extends Record<string, any[]>, Actions extends {
+    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
+} = {
+    [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>>;
+}> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions?: {
+        [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>>;
+    });
+    private _state;
+    get state(): State;
+    dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State;
+}
+export default Store;

package/dist/Classes/store.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+const Events_1 = require("./Events");
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ *
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ *
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType.
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ *
+ * Reducer functions can be removed using Store.off('action', reducer);
+ *
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ *
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ *
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ *
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ *
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, {
+ *          id: Math.random().toString(),
+ *          text,
+ *          completed: false
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ *
+ *      return state.map(todo => (
+ *          todo.id === id ? {
+ *              ...todo,
+ *              completed: force === undefined ? !todo.completed : force
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ *
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ *
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ *
+ * store.dispatch('create', 'Make store!');
+ *
+ * ```
+ */
+class Store extends Events_1.EventEmitter {
+    constructor(state, actions = {}) {
+        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers])));
+        this._state = state;
+    }
+    _state;
+    get state() {
+        return this._state;
+    }
+    dispatch(action, ...args) {
+        const previous = { ...this._state };
+        this._state = super.emit(action, ...args).reduce((state, returned) => ({ ...state, ...returned }), this.state);
+        super.emit('stateChange', ...[previous, this.state]);
+        return this.state;
+    }
+}
+exports.Store = Store;
+exports.default = Store;

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;
+    }
+}