@sapphire/time-utilities 1.7.6-next.fca7a80.0 → 1.7.6

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+# [@sapphire/time-utilities@1.7.6](https://github.com/sapphiredev/utilities/compare/@sapphire/time-utilities@1.7.5...@sapphire/time-utilities@1.7.6) - (2022-08-20)
+
+## 🐛 Bug Fixes
+
+- **deps:** Update all non-major dependencies ([2308bd7](https://github.com/sapphiredev/utilities/commit/2308bd74356b6b2e0c12995b25f4d8ade4803fe9))
+
+## 📝 Documentation
+
+- Fixed typos (#427) ([e840a97](https://github.com/sapphiredev/utilities/commit/e840a9795583b59ee3da9ffe0d325e0a3cfa0c14))
+- Add @muchnameless as a contributor ([a1221fe](https://github.com/sapphiredev/utilities/commit/a1221fea68506e99591d5d00ec552a07c26833f9))
+- Add @enxg as a contributor ([d2382f0](https://github.com/sapphiredev/utilities/commit/d2382f04e3909cb4ad11798a0a10e683f6cf5383))
+- Add @EvolutionX-10 as a contributor ([efc3a32](https://github.com/sapphiredev/utilities/commit/efc3a320a72ae258996dd62866d206c33f8d4961))
+
 # [@sapphire/time-utilities@1.7.5](https://github.com/sapphiredev/utilities/compare/@sapphire/time-utilities@1.7.4...@sapphire/time-utilities@1.7.5) - (2022-07-13)
 
 ## 🏠 Refactor

package/dist/index.d.ts

@@ -1,7 +1,261 @@
-export { Time, TimeTypes } from './lib/constants';
-export * from './lib/Cron';
-export * from './lib/Duration';
-export * from './lib/DurationFormatter';
-export * from './lib/TimerManager';
-export * from './lib/Timestamp';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Display the duration
+ * @param duration The duration in milliseconds to parse and display
+ * @param assets The language assets
+ */
+declare class DurationFormatter {
+    units: DurationFormatAssetsTime;
+    constructor(units?: DurationFormatAssetsTime);
+    format(duration: number, precision?: number, { left: leftSeparator, right: rightSeparator }?: DurationFormatSeparators): string;
+}
+interface DurationFormatSeparators {
+    left?: string;
+    right?: string;
+}
+interface DurationFormatAssetsUnit extends Record<number, string> {
+    DEFAULT: string;
+}
+interface DurationFormatAssetsTime {
+    [TimeTypes.Second]: DurationFormatAssetsUnit;
+    [TimeTypes.Minute]: DurationFormatAssetsUnit;
+    [TimeTypes.Hour]: DurationFormatAssetsUnit;
+    [TimeTypes.Day]: DurationFormatAssetsUnit;
+    [TimeTypes.Week]: DurationFormatAssetsUnit;
+    [TimeTypes.Month]: DurationFormatAssetsUnit;
+    [TimeTypes.Year]: DurationFormatAssetsUnit;
+}
+
+/**
+ * The supported time types
+ */
+declare enum TimeTypes {
+    Second = "second",
+    Minute = "minute",
+    Hour = "hour",
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Year = "year"
+}
+declare enum Time {
+    Millisecond = 1,
+    Second = 1000,
+    Minute = 60000,
+    Hour = 3600000,
+    Day = 86400000,
+    Month = 2628000000,
+    Year = 31536000000
+}
+
+/**
+ * Handles Cron strings and generates dates based on the cron string provided.
+ * @see https://en.wikipedia.org/wiki/Cron
+ */
+declare class Cron {
+    cron: string;
+    normalized: string;
+    minutes: number[];
+    hours: number[];
+    days: number[];
+    months: number[];
+    dows: number[];
+    /**
+     * @param cron The cron pattern to use
+     */
+    constructor(cron: string);
+    /**
+     * Get the next date that matches with the current pattern
+     * @param outset The Date instance to compare with
+     * @param origin Whether this next call is origin
+     */
+    next(outset?: Date, origin?: boolean): Date;
+    /**
+     * Normalize the pattern
+     * @param cron The pattern to normalize
+     */
+    private static normalize;
+    /**
+     * Parse the pattern
+     * @param cron The pattern to parse
+     */
+    private static parseString;
+    /**
+     * Parse the current part
+     * @param cronPart The part of the pattern to parse
+     * @param id The id that identifies the current part
+     */
+    private static parsePart;
+}
+
+/**
+ * Converts duration strings into ms and future dates
+ */
+declare class Duration {
+    /**
+     * The offset
+     */
+    offset: number;
+    /**
+     * Create a new Duration instance
+     * @param pattern The string to parse
+     */
+    constructor(pattern: string);
+    /**
+     * Get the date from now
+     */
+    get fromNow(): Date;
+    /**
+     * Get the date from
+     * @param date The Date instance to get the date from
+     */
+    dateFrom(date: Date): Date;
+    /**
+     * The RegExp used for the pattern parsing
+     */
+    private static readonly kPatternRegex;
+    /**
+     * The RegExp used for removing commas
+     */
+    private static readonly kCommaRegex;
+    /**
+     * The RegExp used for replacing a/an with 1
+     */
+    private static readonly kAanRegex;
+    /**
+     * Parse the pattern
+     * @param pattern The pattern to parse
+     */
+    private static parse;
+}
+
+/**
+ * Manages timers so that this application can be cleanly exited
+ */
+declare class TimerManager extends null {
+    /**
+     * A set of timeouts to clear on destroy
+     */
+    private static storedTimeouts;
+    /**
+     * A set of intervals to clear on destroy
+     */
+    private static storedIntervals;
+    /**
+     * Creates a timeout gets cleared when destroyed
+     * @param fn callback function
+     * @param delay amount of time before running the callback
+     * @param args additional arguments to pass back to the callback
+     */
+    static setTimeout<A = unknown>(fn: (...args: A[]) => void, delay: number, ...args: A[]): NodeJS.Timeout;
+    /**
+     * Clears a timeout created through this class
+     * @param timeout The timeout to clear
+     */
+    static clearTimeout(timeout: NodeJS.Timeout): void;
+    /**
+     * Creates an interval gets cleared when destroyed
+     * @param fn callback function
+     * @param delay amount of time before running the callback
+     * @param args additional arguments to pass back to the callback
+     */
+    static setInterval<A = unknown>(fn: (...args: A[]) => void, delay: number, ...args: A[]): NodeJS.Timeout;
+    /**
+     * Clears an internal created through this class
+     * @param interval The interval to clear
+     */
+    static clearInterval(interval: NodeJS.Timeout): void;
+    /**
+     * Clears running timeouts and intervals created through this class so NodeJS can gracefully exit
+     */
+    static destroy(): void;
+}
+
+declare type TimeResolvable = Date | number | string;
+interface TimestampTemplateEntry {
+    type: string;
+    content: string | null;
+}
+/**
+ * Timestamp class, parses the pattern once, displays the desired Date or UNIX timestamp with the selected pattern.
+ */
+declare class Timestamp {
+    /**
+     * The raw pattern
+     * @since 1.0.0
+     */
+    pattern: string;
+    /**
+     * @since 1.0.0
+     */
+    private template;
+    /**
+     * Starts a new Timestamp and parses the pattern.
+     * @since 1.0.0
+     * @param pattern The pattern to parse
+     */
+    constructor(pattern: string);
+    /**
+     * Display the current date with the current pattern.
+     * @since 1.0.0
+     * @param time The time to display
+     */
+    display(time?: TimeResolvable): string;
+    /**
+     * Display the current date utc with the current pattern.
+     * @since 1.0.0
+     * @param time The time to display in utc
+     */
+    displayUTC(time?: TimeResolvable): string;
+    /**
+     * Edits the current pattern.
+     * @since 1.0.0
+     * @param pattern The new pattern for this instance
+     * @chainable
+     */
+    edit(pattern: string): this;
+    /**
+     * Defines the toString behavior of Timestamp.
+     */
+    toString(): string;
+    /**
+     * Display the current date with the current pattern.
+     * @since 1.0.0
+     * @param pattern The pattern to parse
+     * @param time The time to display
+     */
+    static displayArbitrary(pattern: string, time?: TimeResolvable): string;
+    /**
+     * Display the current date utc with the current pattern.
+     * @since 1.0.0
+     * @param pattern The pattern to parse
+     * @param time The time to display
+     */
+    static displayUTCArbitrary(pattern: string, time?: TimeResolvable): string;
+    /**
+     * Creates a UTC Date object to work with.
+     * @since 1.0.0
+     * @param time The date to convert to utc
+     */
+    static utc(time?: Date | number | string): Date;
+    /**
+     * Display the current date with the current pattern.
+     * @since 1.0.0
+     * @param template The pattern to parse
+     * @param time The time to display
+     */
+    private static display;
+    /**
+     * Parses the pattern.
+     * @since 1.0.0
+     * @param pattern The pattern to parse
+     */
+    private static parse;
+    /**
+     * Resolves a date.
+     * @since 1.0.0
+     * @param time The time to parse
+     */
+    private static resolveDate;
+}
+
+export { Cron, Duration, DurationFormatAssetsTime, DurationFormatAssetsUnit, DurationFormatSeparators, DurationFormatter, Time, TimeResolvable, TimeTypes, TimerManager, Timestamp, TimestampTemplateEntry };

package/dist/index.global.js

@@ -411,40 +411,55 @@ ${expression || zws}\`\`\``;
   }
   __name(filterNullAndUndefinedAndZero, "filterNullAndUndefinedAndZero");
   __name2(filterNullAndUndefinedAndZero, "filterNullAndUndefinedAndZero");
-  function isObject(input, constructorType) {
-    return typeof input === "object" && input ? input.constructor === (constructorType != null ? constructorType : Object) : false;
+  function getDeepObjectKeys(obj, options) {
+    return [...getDeepObjectKeysGenerator(obj, options)];
   }
-  __name(isObject, "isObject");
-  __name2(isObject, "isObject");
-  function getDeepObjectKeys(obj, { arrayKeysIndexStyle = "dotted" } = { arrayKeysIndexStyle: "dotted" }) {
-    const keys = [];
-    for (const [key, value] of Object.entries(obj)) {
-      if (Array.isArray(value)) {
-        for (const [index, innerValue] of value.entries()) {
-          const arraySubKeys = getDeepObjectKeys(innerValue);
-          keys.push(...arraySubKeys.map((arraySubKey) => {
-            switch (arrayKeysIndexStyle) {
-              case "braces-with-dot":
-                return `${key}[${index}].${arraySubKey}`;
-              case "braces":
-                return `${key}[${index}]${arraySubKey}`;
-              case "dotted":
-              default:
-                return `${key}.${index}.${arraySubKey}`;
-            }
-          }));
-        }
-      } else if (isObject(value)) {
-        const objectSubKeys = getDeepObjectKeys(value);
-        keys.push(...objectSubKeys.map((subKey) => `${key}.${subKey}`));
+  __name(getDeepObjectKeys, "getDeepObjectKeys");
+  __name2(getDeepObjectKeys, "getDeepObjectKeys");
+  function* getDeepObjectKeysGenerator(obj, { arrayKeysIndexStyle = "dotted" } = { arrayKeysIndexStyle: "dotted" }) {
+    if (Array.isArray(obj)) {
+      for (const [index, value] of obj.entries()) {
+        yield* getDeepArrayKeysRecursive(value, index, { arrayKeysIndexStyle });
+      }
+    } else {
+      for (const [key, value] of Object.entries(obj)) {
+        yield* getDeepObjectKeysRecursive(value, `${key}`, { arrayKeysIndexStyle });
+      }
+    }
+  }
+  __name(getDeepObjectKeysGenerator, "getDeepObjectKeysGenerator");
+  __name2(getDeepObjectKeysGenerator, "getDeepObjectKeysGenerator");
+  function* getDeepArrayKeysRecursive(value, index, { arrayKeysIndexStyle }) {
+    const resolvedIndex = arrayKeysIndexStyle === "dotted" ? `${index}` : arrayKeysIndexStyle === "braces" ? `[${index}]` : `[${index}].`;
+    yield* getDeepObjectKeysRecursive(value, resolvedIndex, { arrayKeysIndexStyle });
+  }
+  __name(getDeepArrayKeysRecursive, "getDeepArrayKeysRecursive");
+  __name2(getDeepArrayKeysRecursive, "getDeepArrayKeysRecursive");
+  function* getDeepObjectKeysRecursive(obj, prefix, { arrayKeysIndexStyle }) {
+    if (typeof obj !== "object" || obj === null) {
+      yield prefix;
+      return;
+    }
+    if (Array.isArray(obj)) {
+      for (const [index, value] of obj.entries()) {
+        const resolvedPrefixedIndex = arrayKeysIndexStyle === "dotted" ? `${prefix}.${index}` : `${prefix}[${index}]`;
+        yield* getDeepObjectKeysRecursive(value, resolvedPrefixedIndex, { arrayKeysIndexStyle });
+      }
+    } else {
+      const objectEntries = Object.entries(obj);
+      if (isNullOrUndefinedOrEmpty(objectEntries) && prefix) {
+        yield prefix;
       } else {
-        keys.push(key);
+        for (const [key, value] of objectEntries) {
+          yield* getDeepObjectKeysRecursive(value, arrayKeysIndexStyle === "braces" ? `${prefix}${key}` : `${prefix}.${key}`, {
+            arrayKeysIndexStyle
+          });
+        }
       }
     }
-    return keys;
   }
-  __name(getDeepObjectKeys, "getDeepObjectKeys");
-  __name2(getDeepObjectKeys, "getDeepObjectKeys");
+  __name(getDeepObjectKeysRecursive, "getDeepObjectKeysRecursive");
+  __name2(getDeepObjectKeysRecursive, "getDeepObjectKeysRecursive");
   function hasAtLeastOneKeyInMap(map, keys) {
     return keys.some((key) => map.has(key));
   }
@@ -471,6 +486,11 @@ ${expression || zws}\`\`\``;
   }
   __name(isNumber, "isNumber");
   __name2(isNumber, "isNumber");
+  function isObject(input, constructorType) {
+    return typeof input === "object" && input ? input.constructor === (constructorType != null ? constructorType : Object) : false;
+  }
+  __name(isObject, "isObject");
+  __name2(isObject, "isObject");
   function hasThen(input) {
     return Reflect.has(input, "then") && isFunction(input.then);
   }
@@ -619,12 +639,18 @@ ${expression || zws}\`\`\``;
     const { additionalVariants = {}, caseSensitive } = options;
     const titleCaseVariants = {
       ...baseVariants,
-      ...caseSensitive ? additionalVariants : Object.entries(additionalVariants).reduce((variants, [key, variant]) => ({ ...variants, [key.toLowerCase()]: variant }), {})
+      ...caseSensitive ? additionalVariants : Object.entries(additionalVariants).reduce(
+        (variants, [key, variant]) => ({ ...variants, [key.toLowerCase()]: variant }),
+        {}
+      )
     };
-    return str.replace(TO_TITLE_CASE, (txt) => {
-      var _a;
-      return (_a = titleCaseVariants[caseSensitive ? txt : txt.toLowerCase()]) != null ? _a : txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
-    });
+    return str.replace(
+      TO_TITLE_CASE,
+      (txt) => {
+        var _a;
+        return (_a = titleCaseVariants[caseSensitive ? txt : txt.toLowerCase()]) != null ? _a : txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+      }
+    );
   }
   __name(toTitleCase, "toTitleCase");
   __name2(toTitleCase, "toTitleCase");
@@ -674,25 +700,27 @@ ${expression || zws}\`\`\``;
       if (Reflect.has(predefined, cron))
         return Reflect.get(predefined, cron);
       const now = new Date();
-      cron = cron.split(" ").map((val, i) => val.replace(wildcardRegex, (match) => {
-        if (match === "h")
-          return (Math.floor(Math.random() * allowedNum[i][1]) + allowedNum[i][0]).toString();
-        if (match === "?") {
-          switch (i) {
-            case 0:
-              return now.getUTCMinutes().toString();
-            case 1:
-              return now.getUTCHours().toString();
-            case 2:
-              return now.getUTCDate().toString();
-            case 3:
-              return now.getUTCMonth().toString();
-            case 4:
-              return now.getUTCDay().toString();
+      cron = cron.split(" ").map(
+        (val, i) => val.replace(wildcardRegex, (match) => {
+          if (match === "h")
+            return (Math.floor(Math.random() * allowedNum[i][1]) + allowedNum[i][0]).toString();
+          if (match === "?") {
+            switch (i) {
+              case 0:
+                return now.getUTCMinutes().toString();
+              case 1:
+                return now.getUTCHours().toString();
+              case 2:
+                return now.getUTCDate().toString();
+              case 3:
+                return now.getUTCMonth().toString();
+              case 4:
+                return now.getUTCDay().toString();
+            }
           }
-        }
-        return match;
-      })).join(" ");
+          return match;
+        })
+      ).join(" ");
       return cron.replace(tokensRegex, (match) => String(Reflect.get(cronTokens, match)));
     }
     static parseString(cron) {
@@ -815,10 +843,10 @@ ${expression || zws}\`\`\``;
       if (negative)
         duration *= -1;
       for (const [type, timeDuration] of kTimeDurations) {
-        const substraction = duration / timeDuration;
-        if (substraction < 1)
+        const division = duration / timeDuration;
+        if (division < 1)
           continue;
-        const floored = Math.floor(substraction);
+        const floored = Math.floor(division);
         duration -= floored * timeDuration;
         output.push(addUnit(floored, this.units[type], leftSeparator));
         if (output.length >= precision)
@@ -928,19 +956,27 @@ ${expression || zws}\`\`\``;
     ["ll", (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())}`],
     [
       "LLL",
-      (time) => `${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      (time) => `${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(
+        time.getHours() % 12 || 12
+      )}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
     ],
     [
       "lll",
-      (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(
+        time.getHours() % 12 || 12
+      )}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
     ],
     [
       "LLLL",
-      (time) => `${days[time.getDay()]}, ${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      (time) => `${days[time.getDay()]}, ${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(
+        time.getHours() % 12 || 12
+      )}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
     ],
     [
       "llll",
-      (time) => `${days[time.getDay()].slice(0, 3)} ${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      (time) => `${days[time.getDay()].slice(0, 3)} ${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(
+        time.getFullYear()
+      )} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
     ],
     [
       "Z",