danholibraryjs 1.10.0 → 2.0.0

package/src/Classes/Time/Time.ts

@@ -1,38 +1,43 @@
+import { Autocomplete } from "../../Types";
 import { LongDay, LongMonth } from "../../Types/Date";
 
 /** '2s' or 2000 */
-export type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd'| 'w' | 'M' | 'y';
+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
+ * Converts input into milliseconds. Supports multiple time units in one string by space separation. E.g. 1h 30m
  * @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;
+export function ms(input: Autocomplete<TimeDelay>) {
+  return input.toString().split(' ').reduce((result, unit) => result += msSingular(unit as TimeDelay), 0);
+}
+
+function msSingular(input: TimeDelay) {
+  if (typeof input === 'number') return input;
 
-    const match = input.match(ValidTime);
-    if (!match) throw Error(`Invalid input string "${input}"`)
-    match.shift();
+  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]
-    ]);
+  const [value, unit] = match;
+  // console.log({ value, unit, input, match });
 
-    return parseInt(value) * (units.get(unit) as number);
+  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);
 }
 
 /**
@@ -41,94 +46,94 @@ export function ms(input: 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]
-    }
+  /**
+   * 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 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;;
+  }
 
-    /**
-     * 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();
+  }
 
-    /**
-     * 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;
+  }
 
-    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 indexed
+   */
+  public static get MonthNames() {
+    return new Array<LongMonth>(
+      'January', 'February',
+      'March', 'April', 'May',
+      'June', 'July', 'August',
+      'September', 'October', 'November',
+      'December'
+    );
+  }
 
-    /**
-     * 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');
+  }
 
-    /**
-     * 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);
-    }
+  /** 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: Autocomplete<TimeDelay>) {
+    return ms(input);
+  }
 }
 export default Time;

package/src/Classes/Time/TimeSpan.ts

@@ -6,7 +6,7 @@ import TimeProperties from "./TimeProperties";
 /**
  * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
  */
-export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>
+export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
 
 /**
  * Timespan between 2 dates.
@@ -15,181 +15,181 @@ export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number,
  * @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);
-    }
+  constructor(from: DanhoDateConstructor, to: DanhoDateConstructor = Date.now()) {
+    //General properties
+    this.from = new DanhoDate(from);
+    this.to = new DanhoDate(to);
 
-    /**
-     * 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)
-    }
+    //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();
 
-    /**
-     * 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];
-    }
+    //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);
+  }
 
-    /**
-     * 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]
-    }
+  /**
+   * 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;
 
-    /**
-     * 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) || '';
+  /**
+   * 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/index.ts

@@ -1,3 +1,4 @@
 export * from './Events';
 export * from './Time';
+export * from './DanhoLogger';
 export * from './store';