danholibraryjs 1.5.0 → 1.8.0

package/dist/Classes/{EventEmitter.d.ts → Events/EventEmitter.d.ts}

@@ -1,11 +1,37 @@
-import BaseEvent from '../Interfaces/BaseEventInterface';
-import EventHandler from '../Types/EventHandler';
+import { BaseEvent, EventHandler } from '../../Types';
 /**
  * Traditional Node.js EventEmitter for vanilla JavaScript
+ * @borrows EventCollection
+ * @borrows BaseEvent
+ * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
-export declare class EventEmitter<Events extends BaseEvent> {
+export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events?: Map<keyof Events, EventHandler<Events, keyof Events>[]>);
+    constructor(events?: Map<keyof Events, EventHandler<Events>>);
     /**@private Internal event collection*/
     private _events;
     /**
@@ -21,14 +47,14 @@ export declare class EventEmitter<Events extends BaseEvent> {
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    once<Return extends any, Event extends keyof Events>(event: keyof Events, listener: EventHandler<Events, Event, Return>): this;
+    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this;
     /**
      * Removes listener(s) from event
      * @param event Event to get collection of listeners | "all"
      * @param listener If left null, removes all listeners tied to event, else only removes listener from event
      * @returns this
      */
-    off<Event extends keyof Events>(event?: Event | string, listener?: EventHandler<Events, Event>): this;
+    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): this;
     /**
      * Emits event and runs all listeners tied to event
      * @param event Event to emit
@@ -36,7 +62,7 @@ export declare class EventEmitter<Events extends BaseEvent> {
      * @fires event
      * @returns Array of listeners' reponses
      */
-    emit<ReturnType extends any, Event extends keyof Events>(event: Event, args: Events[Event]): ReturnType[];
+    emit<Return extends any, Event extends keyof Events>(event: Event, ...args: Events[Event]): Array<Return>;
     /**
      * Limits how many events to accept using EventEmitter#on or EventEmitter#once
      * @param event: Specific event to limit, or by default, 'all'

package/dist/Classes/{EventEmitter.js → Events/EventEmitter.js}

@@ -1,9 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventEmitter = void 0;
-const EventCollection_1 = require("./EventCollection");
+const EventCollection_1 = __importDefault(require("./EventCollection"));
 /**
  * Traditional Node.js EventEmitter for vanilla JavaScript
+ * @borrows EventCollection
+ * @borrows BaseEvent
+ * @borrows EventHandler
+ *
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ *
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ *
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ *
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
 class EventEmitter {
     /**@param events Map<name: string, handlers: EventHandler[]>*/
@@ -49,8 +79,8 @@ class EventEmitter {
      * @fires event
      * @returns Array of listeners' reponses
      */
-    emit(event, args) {
-        return this._events.emit(event, args);
+    emit(event, ...args) {
+        return this._events.emit(event, ...args);
     }
     /**
      * Limits how many events to accept using EventEmitter#on or EventEmitter#once

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

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

package/dist/Classes/Events/index.js

@@ -0,0 +1,19 @@
+"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("./Event"), exports);
+__exportStar(require("./EventCollection"), exports);
+__exportStar(require("./EventEmitter"), exports);

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

@@ -0,0 +1,147 @@
+import { BetterOmit, PartialExcept, LongMonth, LongDay, ShortDay, ShortMonth } from "../../Types";
+import TimeProperties from "./TimeProperties";
+import TimeSpan, { TimeSpanFormat } from "./TimeSpan";
+declare type Data = PartialExcept<BetterOmit<TimeProperties<true>, 'weeks'>, 'years' | 'months'>;
+declare type Double = `${number}${number}`;
+declare type Quadruple = `${Double}${Double}`;
+declare type DateFormat = `${Double}/${Double}/${Quadruple}`;
+/**
+ * Type used to construct DanhoDate.
+ * @Data Partial TimeProperties except years & months
+ * @DateFormat string as dd/MM/yyyy
+ */
+export declare type DanhoDateConstructor = Data | DateFormat | number | Date;
+declare class DanhoDate {
+    /**
+     * Returns the value of the current irl time
+     */
+    static get now(): number;
+    constructor(data?: DanhoDateConstructor);
+    private _formats;
+    private _format;
+    date: Date;
+    /**
+     * Year of the date
+     */
+    get year(): number;
+    set year(value: number);
+    /**
+     * Month of the date
+     */
+    get month(): number;
+    set month(value: number);
+    /**
+     * Days in the month of the date
+     */
+    get daysInMonth(): number;
+    /**
+     * Week of the year the day is in
+     */
+    get week(): number;
+    set week(value: number);
+    /**
+     * Week of the month the day is in
+     */
+    get weekOfMonth(): number;
+    /**
+     * Day of the date
+     */
+    get day(): number;
+    set day(value: number);
+    get dayOfWeek(): number;
+    set dayOfWeek(value: number);
+    /**
+     * Hours of the date
+     */
+    get hours(): number;
+    set hours(value: number);
+    get isPM(): boolean;
+    /**
+     * Minutes of the date
+     */
+    get minutes(): number;
+    set minutes(value: number);
+    /**
+     * Seconds of the date
+     */
+    get seconds(): number;
+    set seconds(value: number);
+    /**
+     * Milliseconds of the date
+     */
+    get milliseconds(): number;
+    set milliseconds(value: number);
+    /**
+     * Millisecond value of internal time
+     */
+    get time(): number;
+    set time(value: number);
+    /**
+     * Week day i.e. Monday
+     */
+    get weekDay(): LongDay;
+    /**
+     * Short week day i.e. Mon
+     */
+    get weekDayShort(): ShortDay;
+    /**
+     * Month name i.e. February
+     */
+    get monthName(): LongMonth;
+    /**
+     * Short month name i.e. Feb
+     */
+    get monthNameShort(): 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
+     */
+    set(data: Partial<Data>): this;
+    /**
+     * Calculates the time between this and provided date
+     * @param date Date information
+     * @returns TimeSpan between this and provided date
+     */
+    between(date?: DanhoDate | DanhoDateConstructor): TimeSpan;
+    /**
+     * 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
+     */
+    toString(format?: string, relativeFormat?: TimeSpanFormat): string;
+}
+export { DanhoDate as Date };
+export default DanhoDate;

package/dist/Classes/Time/Date.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Date = void 0;
+const Time_1 = __importDefault(require("./Time"));
+const TimeSpan_1 = __importDefault(require("./TimeSpan"));
+class DanhoDate {
+    /**
+     * Returns the value of the current irl time
+     */
+    static get now() {
+        return Date.now();
+    }
+    constructor(data) {
+        // 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([
+            ['year', this.year],
+            ['daysInMonth', this.daysInMonth],
+            ['monthShort', this.monthNameShort],
+            ['month', this.monthName],
+            ['MM', Time_1.default.DoubleDigit(this.month)],
+            ['M', this.month],
+            ['weekMonth', this.weekOfMonth],
+            ['weekDay', this.weekDay],
+            ['weekDayShort', this.weekDayShort],
+            ['week', this.week],
+            ['dd', Time_1.default.DoubleDigit(this.day)],
+            ['ddth', `${Time_1.default.DoubleDigit(this.day)}${Time_1.default.th(this.day)}`],
+            ['d', this.day],
+            ['dth', Time_1.default.th(this.day, true)],
+            ['hh12', `${Time_1.default.DoubleDigit(this.hours)}${this.hours < 12 ? 'AM' : 'PM'}`],
+            ['h12', `${this.hours > 12 ? 12 - this.hours : this.hours}${this.hours < 12 ? 'AM' : 'PM'}`],
+            ['hh24', Time_1.default.DoubleDigit(this.hours)],
+            ['h24', this.hours],
+            ['mm', Time_1.default.DoubleDigit(this.minutes)],
+            ['m', this.minutes],
+            ['ss', Time_1.default.DoubleDigit(this.seconds)],
+            ['s', this.seconds],
+            ['msms', Time_1.default.DoubleDigit(this.milliseconds)],
+            ['ms', this.milliseconds]
+        ]).map((v, k) => [k, v.toString()]);
+    }
+    _formats;
+    _format(format) {
+        return format
+            .split(/\$/)
+            .map(v => v.split(/\W/)[0])
+            .filter(v => v)
+            .reduce((result, key) => result.replaceAll(key, this._formats.get(key)), format.replaceAll('$', ''));
+    }
+    date;
+    /**
+     * Year of the date
+     */
+    get year() { return this.date.getFullYear(); }
+    set year(value) { this.date.setFullYear(value); }
+    /**
+     * Month of the date
+     */
+    get month() { return this.date.getMonth() + 1; }
+    set month(value) { this.date.setMonth(value); }
+    /**
+     * Days in the month of the date
+     */
+    get daysInMonth() { return Time_1.default.daysInMonth[this.month - 1]; }
+    /**
+     * Week of the year the day is in
+     */
+    get week() {
+        const firstMonday = new Date(this.year, 1, 1);
+        if (firstMonday.getDay() !== 1) {
+            const daysToMon = Time_1.default.DayNames.reverse().reduce((result, day, i) => result.set(day, i + 1), new Map()).get(Time_1.default.DayNames[firstMonday.getDay() - 1]);
+            firstMonday.setDate(firstMonday.getDate() + daysToMon);
+        }
+        const timeDiff = Math.round(firstMonday.getTime() - this.time);
+        const timeSince = Time_1.default.millisecond % timeDiff;
+        const result = Math.ceil(timeSince / Time_1.default.week);
+        return result;
+    }
+    set week(value) { this.date.setDate(value * Time_1.default.week / Time_1.default.day); }
+    /**
+     * Week of the month the day is in
+     */
+    get weekOfMonth() { return Math.round(this.daysInMonth / (Time_1.default.week / Time_1.default.day)); }
+    /**
+     * Day of the date
+     */
+    get day() { return this.date.getDate(); }
+    set day(value) { this.date.setDate(value); }
+    get dayOfWeek() { return this.date.getDay(); }
+    set dayOfWeek(value) {
+        const current = this.dayOfWeek;
+        if (value > current)
+            var diff = value - current;
+        else
+            diff = current - value;
+        this.day -= diff;
+    }
+    /**
+     * Hours of the date
+     */
+    get hours() { return this.date.getHours(); }
+    set hours(value) { this.date.setHours(value); }
+    get isPM() {
+        return this.hours > 11;
+    }
+    /**
+     * Minutes of the date
+     */
+    get minutes() { return this.date.getMinutes(); }
+    set minutes(value) { this.date.setMinutes(value); }
+    /**
+     * Seconds of the date
+     */
+    get seconds() { return this.date.getSeconds(); }
+    set seconds(value) { this.date.setSeconds(value); }
+    /**
+     * Milliseconds of the date
+     */
+    get milliseconds() { return this.date.getMilliseconds(); }
+    set milliseconds(value) { this.date.setMilliseconds(value); }
+    /**
+     * Millisecond value of internal time
+     */
+    get time() { return this.date.getTime(); }
+    set time(value) { this.date.setTime(value); }
+    /**
+     * Week day i.e. Monday
+     */
+    get weekDay() { return Time_1.default.DayNames[this.dayOfWeek - 1] || Time_1.default.DayNames.at(-1); }
+    /**
+     * Short week day i.e. Mon
+     */
+    get weekDayShort() { return this.weekDay.substring(0, 3); }
+    /**
+     * Month name i.e. February
+     */
+    get monthName() { return Time_1.default.MonthNames[this.month - 1] || Time_1.default.MonthNames.at(-1); }
+    /**
+     * Short month name i.e. Feb
+     */
+    get monthNameShort() { return this.monthName.substring(0, 3); }
+    /**
+     * Sets internal date property
+     * @param data Time properties to set - replacement of i.e. Date.setHours(value: number): number
+     * @returns This, with updated properties
+     */
+    set(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
+     */
+    between(date) {
+        if (!date)
+            return new TimeSpan_1.default(this.date, new Date());
+        else if (date instanceof DanhoDate)
+            return new TimeSpan_1.default(this.date, date.date);
+        else if (date instanceof Date)
+            return new TimeSpan_1.default(this.date, date);
+        else if (typeof date === 'object')
+            return new DanhoDate(date).between(this.date);
+        return new TimeSpan_1.default(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
+     */
+    toString(format = "$dd/$MM/$year", relativeFormat) {
+        return this._format(format.replaceAll('$relative', this.between(new Date()).toString(relativeFormat)));
+    }
+}
+exports.Date = DanhoDate;
+exports.default = DanhoDate;

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

@@ -0,0 +1,65 @@
+import { LongMonth } from "../../Types/Date";
+/** '2s' or 2000 */
+export declare type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
+export declare type TimeString = `${number}${TimeUnit}`;
+export declare type TimeDelay = number | TimeString;
+export declare const ValidTime: RegExp;
+/**
+ * Converts input into milliseconds
+ * @param input Input to convert to ms. 1s | 2m | 3h | 1M | 60000
+ * @returns Millisecond value of input
+ */
+export declare function ms(input: TimeDelay): number;
+/**
+ * Time utility class
+ * @borrows TimeDelay
+ * @borrows ms
+ */
+export declare class Time {
+    /**
+     * Array of amount of days in the months. 0 indexed
+     */
+    static get daysInMonth(): number[];
+    /**
+     * Amount of weeks per year
+     */
+    static get weeksInYear(): number;
+    /**
+     * Amount of days per year
+     */
+    static get daysInYear(): number;
+    /**
+     * Returns function that converts value into double digit string
+     * @returns (value: number): string
+     */
+    static DoubleDigit(value: number): string;
+    static th(value: number, includeValue?: boolean): string;
+    /**
+     * Array of names of the months. 0 idnexed
+     */
+    static get MonthNames(): LongMonth[];
+    /**
+     * Array of names of the days of the week. 0 indexed
+     */
+    static get DayNames(): ("Monday" | "Friday" | "Sunday" | "Tuesday" | "Wednesday" | "Thursday" | "Saturday")[];
+    /** Millisecond in milliseconds (I know that sounds weird but the others make sense) */
+    static get millisecond(): number;
+    /** Second in milliseconds */
+    static get second(): number;
+    /** Minute in milliseconds */
+    static get minute(): number;
+    /** Hour in milliseconds */
+    static get hour(): number;
+    /** Day in milliseconds */
+    static get day(): number;
+    /** Week in milliseconds */
+    static get week(): number;
+    /** Month in milliseconds */
+    static get month(): number;
+    /** Year in milliseconds */
+    static get year(): number;
+    /** Average month in milliseconds */
+    static get avgMonth(): number;
+    static ms(input: TimeDelay): number;
+}
+export default Time;