danholibraryjs 1.5.0 → 1.8.0

package/src/Classes/Time/Date.ts

@@ -0,0 +1,264 @@
+import { BetterOmit, PartialExcept, LongMonth, LongDay, ShortDay, ShortMonth } from "../../Types";
+import Time from "./Time";
+import TimeProperties from "./TimeProperties";
+import TimeSpan, { TimeSpanFormat } from "./TimeSpan";
+
+type Data = PartialExcept<BetterOmit<TimeProperties<true>, 'weeks'>, 'years' | 'months'>;
+type Double = `${number}${number}`;
+type Quadruple = `${Double}${Double}`;
+type DateFormat = `${Double}/${Double}/${Quadruple}`;
+/**
+ * Type used to construct DanhoDate.
+ * @Data Partial TimeProperties except years & months
+ * @DateFormat string as dd/MM/yyyy
+ */
+export type DanhoDateConstructor = Data | DateFormat | number | Date;
+
+class DanhoDate {
+    /**
+     * Returns the value of the current irl time
+     */
+    public static get now() {
+        return Date.now();
+    }
+
+    constructor(data?: DanhoDateConstructor) {
+        // data not provided
+        if (!data) this.date = new Date();
+        // data is typeof Date
+        else if (typeof data === 'object' && data instanceof Date) {
+            this.date = new Date(data);
+        } 
+        // data is typeof Data
+        else if (typeof data === 'object') {
+            this.date = new Date(data.years, data.months - 1);
+            if (data.days) this.date.setDate(data.days);
+            if (data.hours) this.date.setHours(data.hours);
+            if (data.minutes) this.date.setMinutes(data.minutes);
+            if (data.seconds) this.date.setSeconds(data.seconds);
+            if (data.milliseconds) this.date.setMilliseconds(data.milliseconds);
+        }
+        // data is string or number
+        else this.date = new Date(data);
+
+        this._formats = new Map<string, string | number>([
+            ['year', this.year],
+            ['daysInMonth', this.daysInMonth],
+            ['monthShort', this.monthNameShort],
+            ['month', this.monthName],
+            ['MM', Time.DoubleDigit(this.month)],
+            ['M', this.month],
+
+            ['weekMonth', this.weekOfMonth],
+            ['weekDay', this.weekDay],
+            ['weekDayShort', this.weekDayShort],
+            ['week', this.week],
+
+            ['dd', Time.DoubleDigit(this.day)],
+            ['ddth', `${Time.DoubleDigit(this.day)}${Time.th(this.day)}`],
+            ['d', this.day],
+            ['dth', Time.th(this.day, true)],
+
+            ['hh12', `${Time.DoubleDigit(this.hours)}${this.hours < 12 ? 'AM' : 'PM'}`],
+            ['h12', `${this.hours > 12 ? 12 - this.hours : this.hours}${this.hours < 12 ? 'AM' : 'PM'}`],
+            ['hh24', Time.DoubleDigit(this.hours)],
+            ['h24', this.hours],
+            ['mm', Time.DoubleDigit(this.minutes)],
+            ['m', this.minutes],
+            ['ss', Time.DoubleDigit(this.seconds)],
+            ['s', this.seconds],
+            ['msms', Time.DoubleDigit(this.milliseconds)],
+            ['ms', this.milliseconds]
+        ]).map((v, k) => [k, v.toString()])
+    }
+
+    private _formats: Map<string, string>;
+    private _format(format: string) {
+        return format
+            .split(/\$/)
+            .map(v => v.split(/\W/)[0])
+            .filter(v => v)
+            .reduce((result, key) => result.replaceAll(key, this._formats.get(key)!), format.replaceAll('$', ''));
+    }
+
+    public date: Date
+
+    /**
+     * Year of the date
+     */
+    public get year(): number { return this.date.getFullYear() }
+    public set year(value: number) { this.date.setFullYear(value); }
+
+    /**
+     * Month of the date
+     */
+    public get month(): number { return this.date.getMonth() + 1 }
+    public set month(value: number) { this.date.setMonth(value) }
+
+    /**
+     * Days in the month of the date
+     */
+    public get daysInMonth() { return Time.daysInMonth[this.month - 1]; }
+
+    /**
+     * Week of the year the day is in
+     */
+    public get week(): number {
+        const firstMonday = new Date(this.year, 1, 1);
+
+        if (firstMonday.getDay() !== 1) {
+            const daysToMon = Time.DayNames.reverse().reduce((result, day, i) => 
+                result.set(day, i + 1)
+            , new Map<LongDay, number>()).get(Time.DayNames[firstMonday.getDay() - 1])!;
+            firstMonday.setDate(firstMonday.getDate() + daysToMon);
+        }
+
+        const timeDiff = Math.round(firstMonday.getTime() - this.time);
+        const timeSince = Time.millisecond % timeDiff;
+        const result = Math.ceil(timeSince / Time.week);
+        return result;
+    }
+    public set week(value: number) { this.date.setDate(value * Time.week / Time.day); }
+
+    /**
+     * Week of the month the day is in
+     */
+    public get weekOfMonth(): number { return Math.round(this.daysInMonth / (Time.week / Time.day)); }
+
+    /**
+     * Day of the date
+     */
+    public get day(): number { return this.date.getDate(); }
+    public set day(value: number) { this.date.setDate(value); }
+
+    public get dayOfWeek(): number { return this.date.getDay() }
+    public set dayOfWeek(value: number) {
+        const current = this.dayOfWeek;
+
+        if (value > current) var diff = value - current;
+        else diff = current - value;
+
+        this.day -= diff;
+    }
+
+    /**
+     * Hours of the date
+     */
+    public get hours(): number { return this.date.getHours(); }
+    public set hours(value: number) { this.date.setHours(value); }
+
+    public get isPM(): boolean {
+        return this.hours > 11;
+    }
+
+    /**
+     * Minutes of the date
+     */
+    public get minutes(): number { return this.date.getMinutes(); }
+    public set minutes(value: number) { this.date.setMinutes(value); }
+
+    /**
+     * Seconds of the date
+     */
+    public get seconds(): number { return this.date.getSeconds(); }
+    public set seconds(value: number) { this.date.setSeconds(value); }
+
+    /**
+     * Milliseconds of the date
+     */
+    public get milliseconds(): number { return this.date.getMilliseconds(); }
+    public set milliseconds(value: number) { this.date.setMilliseconds(value); }
+
+    /**
+     * Millisecond value of internal time
+     */
+    public get time(): number { return this.date.getTime(); }
+    public set time(value: number) { this.date.setTime(value) }
+
+    /**
+     * Week day i.e. Monday
+     */
+    public get weekDay(): LongDay { return Time.DayNames[this.dayOfWeek - 1] || Time.DayNames.at(-1); }
+    /**
+     * Short week day i.e. Mon
+     */
+    public get weekDayShort(): ShortDay { return this.weekDay.substring(0, 3) as ShortDay; }
+    /**
+     * Month name i.e. February
+     */
+    public get monthName(): LongMonth { return Time.MonthNames[this.month - 1] || Time.MonthNames.at(-1); }
+    /**
+     * Short month name i.e. Feb
+     */
+    public get monthNameShort(): ShortMonth { return this.monthName.substring(0, 3) as ShortMonth; }
+
+    /**
+     * Sets internal date property
+     * @param data Time properties to set - replacement of i.e. Date.setHours(value: number): number
+     * @returns This, with updated properties
+     */
+    public set(data: Partial<Data>) {
+        const { years, months, days, hours, minutes, seconds, milliseconds } = data;
+        const ymd = this.date.setFullYear(years || this.year, months, days);
+        const hmsms = new Date(ymd).setHours(hours || this.hours, minutes, seconds, milliseconds);
+        this.date = new Date(hmsms);
+        return this;
+    }
+
+    /**
+     * Calculates the time between this and provided date
+     * @param date Date information
+     * @returns TimeSpan between this and provided date
+     */
+    public between(date?: DanhoDate | DanhoDateConstructor): TimeSpan {
+        if (!date) return new TimeSpan(this.date, new Date());
+        else if (date instanceof DanhoDate) return new TimeSpan(this.date, date.date);
+        else if (date instanceof Date) return new TimeSpan(this.date, date);
+        else if (typeof date === 'object') return new DanhoDate(date).between(this.date);
+        return new TimeSpan(this.date, new Date(date));
+    }
+
+    /**
+     * String representation of this 
+     * @param format String format of date
+     * @returns String representation of this
+     * 
+     * @$year Replaced with year of the date i.e. 2022
+     * 
+     * @$month Replaced with month name i.e. March
+     * @$daysInMonth Replaced with the amount of days in the month i.e. 31
+     * @$MM replaced with double digit month i.e. 01
+     * @$M replaced with single digit month i.e. 1
+     * 
+     * @$week Replaced with week of the year i.e. 32
+     * @$weekOfMonth Replaced with the week of the month i.e. 3
+     * 
+     * @$weekday Replaced with day of the week i.e. Wednesday
+     * @$dd Replaced with double digit day i.e. 02
+     * @$d Replaced with single digit day i.e. 2
+     * @$ddth Replaced with double digit day + "th" i.e. 05th
+     * @$dth Replaced with double digit day + "th" i.e. 5th
+     * 
+     * @$hh12 Replaced with double digit hour in 12-hour format i.e. 09
+     * @$hh24 Replaced with double digit hour in 24-hour format i.e. 21
+     * @$h12 Replaced with single digit hour in 12-hour format i.e. 9
+     * @$h24 Replaced with single digit hour in 24-hour format i.e. 9
+     * 
+     * @$mm Replaced with double digit minute i.e. 05
+     * @$m Replaced with single digit minute i.e. 5
+     * 
+     * @$ss Replaced with double digit second i.e. 03
+     * @$s Replaced with single digit second i.e. 3
+     * 
+     * @msms Replaced with double digit millisecond i.e. 02
+     * @ms Replaced with single digit millisecond i.e. 2
+     * 
+     * @$relative Replaced with relative timeformat as TimeSpan
+     */
+    public toString(format = "$dd/$MM/$year", relativeFormat?: TimeSpanFormat) {
+        return this._format(format.replaceAll('$relative', this.between(new Date()).toString(relativeFormat)))
+    }
+
+}
+export { DanhoDate as Date }
+export default DanhoDate;

package/src/Classes/Time/Time.ts

@@ -0,0 +1,134 @@
+import { LongDay, LongMonth } from "../../Types/Date";
+
+/** '2s' or 2000 */
+export type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd'| 'w' | 'M' | 'y';
+export type TimeString = `${number}${TimeUnit}`;
+export type TimeDelay = number | TimeString;
+export const 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
+ */
+export function ms(input: TimeDelay) {
+    if (typeof input === 'number') return input;
+
+    const match = input.match(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<string, number>([
+        ['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) as number);
+}
+
+/**
+ * Time utility class
+ * @borrows TimeDelay
+ * @borrows ms
+ */
+export class Time {
+    /**
+     * Array of amount of days in the months. 0 indexed
+     */
+    public static get daysInMonth() {
+        return [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    }
+
+    /**
+     * Amount of weeks per year
+     */
+    public static get weeksInYear() {
+        return Time.daysInYear * Time.day / Time.week
+    }
+
+    /**
+     * Amount of days per year
+     */
+    public static get daysInYear() {
+        return Time.year / Time.day;;
+    }
+
+    /**
+     * Returns function that converts value into double digit string
+     * @returns (value: number): string 
+     */
+    public static DoubleDigit(value: number) {
+        return value.toString().length < 2 ? `0${value}` : value.toString(); 
+    }
+
+    public static th(value: number, 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
+     */
+    public static get MonthNames() {
+        return new Array<LongMonth>(
+            'Janurary', 'February', 
+            'March', 'April', 'May',
+            'June', 'July', 'August',
+            'September', 'October', 'November',
+            'December'
+        );
+    }
+
+    /**
+     * Array of names of the days of the week. 0 indexed
+     */
+    public static get DayNames() {
+        return new Array<LongDay>('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday');
+    }
+        
+    /** Millisecond in milliseconds (I know that sounds weird but the others make sense) */
+    public static get millisecond(): number { return 1; }
+    /** Second in milliseconds */
+    public static get second(): number { return Time.millisecond * 1000; }
+    /** Minute in milliseconds */
+    public static get minute(): number { return Time.second * 60; }
+    /** Hour in milliseconds */
+    public static get hour(): number { return Time.minute * 60; }
+    /** Day in milliseconds */
+    public static get day(): number { return Time.hour * 24 }
+    /** Week in milliseconds */
+    public static get week(): number { return Time.day * 7; }
+    /** Month in milliseconds */
+    public static get month(): number {
+        return Time.avgMonth * Time.day;
+    }
+    /** Year in milliseconds */
+    public static get year(): number {
+        const now = new Date()
+        return (365 + (now.getFullYear() % 4 == 0 ? 1 : 0)) * Time.day
+    }
+    /** Average month in milliseconds */
+    public static get avgMonth(): number {
+        return Math.round(this.daysInMonth.reduce((result, num) => result += num, 0) / 12)
+    }
+    public static ms(input: TimeDelay) {
+        return ms(input);
+    }
+}
+export default Time;

package/src/Classes/Time/TimeProperties.ts

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

package/src/Classes/Time/TimeSpan.ts

@@ -0,0 +1,195 @@
+import { TransformType } from "../../Types";
+import DanhoDate, { DanhoDateConstructor } from "./Date";
+import Time from "./Time";
+import TimeProperties from "./TimeProperties";
+
+/**
+ * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
+ */
+export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>
+
+/**
+ * Timespan between 2 dates.
+ * @borrows TimeSpanValue
+ * @borrows Time
+ * @borrows TimeProperties
+ */
+export class TimeSpan implements TimeProperties<true> {
+    constructor(from: DanhoDateConstructor, to: DanhoDateConstructor = Date.now()) {
+        //General properties
+        this.from = new DanhoDate(from);
+        this.to = new DanhoDate(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 DanhoDate(this._highest.time + Time.millisecond);
+        let timeDifference = this._getTimeDifference();
+
+        //Calculate time difference between from & to and set to object properties
+        [this.years, timeDifference] = this._reduceTime(Time.year, timeDifference);
+        [this.months, timeDifference] = this._reduceTime(Time.month, timeDifference);
+        [this.weeks, timeDifference] = this._reduceTime(Time.week, timeDifference);
+        [this.days, timeDifference] = this._reduceTime(Time.day, timeDifference);
+        [this.hours, timeDifference] = this._reduceTime(Time.hour, timeDifference);
+        [this.minutes, timeDifference] = this._reduceTime(Time.minute, timeDifference);
+        [this.seconds, timeDifference] = this._reduceTime(Time.second, timeDifference);
+        [this.milliseconds, timeDifference] = this._reduceTime(Time.millisecond, timeDifference);
+    }
+
+    /**
+     * Which of the dates in constructor had the highest getTime()
+     */
+    private _highest: DanhoDate;
+    /**
+     * Which of the dates in constructor had the lowest getTime()
+     */
+    private _lowest: DanhoDate;
+
+    /**
+     * The time difference between highest and lowest
+     * @returns Time difference in ms between this._highest and this._lowest
+     */
+    private _getTimeDifference(): number {
+        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
+     */
+    private _reduceTime(ms: number, timeDifference: number) {
+        let result = 0;
+
+        while (timeDifference > ms) {
+            timeDifference -= ms;
+            result++;
+        }
+
+        return [result, timeDifference];
+    }
+
+    /**
+     * Total years between dates
+     */
+    public years: number;
+    /**
+     * Total months between dates
+     */
+    public months: number;
+    /**
+     * Total weeks between dates
+     */
+    public weeks: number;
+    /**
+     * Total days between dates
+     */
+    public days: number;
+    /**
+     * Total hours between dates
+     */
+    public hours: number;
+    /**
+     * Total minutes between dates
+     */
+    public minutes: number;
+    /**
+     * Total seconds between dates
+     */
+    public seconds: number;
+    /**
+     * Total milliseconds between dates
+     */
+    public 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(unit: number): number {
+        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
+     */
+    public getTotalMonths(): number {
+        return this._getTotalUnit(Time.month);
+    }
+    /**
+     * Get the maximum amount of weeks between the two dates
+     * @returns Number of max amount of weeks that are between the two dates
+     */
+    public getTotalWeeks(): number {
+        return this._getTotalUnit(Time.week);
+    }
+    /**
+     * Get the maximum amount of days between the two dates
+     * @returns Number of max amount of days that are between the two dates
+     */
+    public getTotalDays(): number {
+        return this._getTotalUnit(Time.day);
+    }
+    /**
+     * Get the maximum amount of hours between the two dates
+     * @returns Number of max amount of hours that are between the two dates
+     */
+    public getTotalHours(): number {
+        return this._getTotalUnit(Time.hour);
+    }
+    /**
+     * Get the maximum amount of minutes between the two dates
+     * @returns Number of max amount of minutes that are between the two dates
+     */
+    public getTotalMinutes(): number {
+        return this._getTotalUnit(Time.minute);
+    }
+    /**
+     * Get the maximum amount of seconds between the two dates
+     * @returns Number of max amount of seconds that are between the two dates
+     */
+    public getTotalSeconds(): number {
+        return this._getTotalUnit(Time.second)
+    }
+    /**
+     * Get the maximum amount of milliseconds between the two dates
+     * @returns Number of max amount of milliseconds that are between the two dates
+     */
+    public getTotalMilliseconds(): number {
+        return this._getTotalUnit(Time.millisecond);
+    }
+    
+    /**
+     * Start date of timespan
+     */
+    public from: DanhoDate;
+    /**
+     * End date of timespan
+     */
+    public to: DanhoDate;
+    /**
+     * Timespan is in the past
+     */
+    public pastTense: boolean;
+
+    public toString(format?: TimeSpanFormat) {
+        //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 as any)[timeMsg[i]] === true : true) ? 
+                `${result}${times[i]} ${timeMsg[i]}${times[i] != 1 ? 's' : ''}, ` : 
+                result
+        ), '');
+
+        return result.length > 2 && result.substring(0, result.length - 2) || '';
+    }
+}
+
+export default TimeSpan;

package/src/Classes/Time/index.ts

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

package/src/Classes/index.ts

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