@skyhelperbot/utils 2.0.1 → 2.0.2-dev

package/dist/classes/LeaderBoardCard.js

@@ -118,11 +118,11 @@ export class LeaderboardCard {
         }
     }
     async build() {
-        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/circularstd-black.otf`), "circular-std");
-        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notosans-jp-black.ttf`), "noto-sans-jp");
-        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notosans-black.ttf`), "noto-sans");
-        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notoemoji-bold.ttf`), "noto-emoji");
-        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notosans-kr-black.ttf`), "noto-sans-kr");
+        GlobalFonts.registerFromPath(path.join(import.meta.dirname, `../../shared/fonts/circularstd-black.otf`), "circular-std");
+        GlobalFonts.registerFromPath(path.join(import.meta.dirname, `../../shared/fonts/notosans-jp-black.ttf`), "noto-sans-jp");
+        GlobalFonts.registerFromPath(path.join(import.meta.dirname, `../../shared/fonts/notosans-black.ttf`), "noto-sans");
+        GlobalFonts.registerFromPath(path.join(import.meta.dirname, `../../shared/fonts/notoemoji-bold.ttf`), "noto-emoji");
+        GlobalFonts.registerFromPath(path.join(import.meta.dirname, `../../shared/fonts/notosans-kr-black.ttf`), "noto-sans-kr");
         const abbreviateNumber = (value) => {
             let newValue = value;
             if (value >= 1000) {

package/dist/classes/SkytimesUtils.d.ts

@@ -1,28 +1,27 @@
-import moment from "moment-timezone";
-import "moment-duration-format";
 import { eventData } from "../constants/eventDatas.js";
+import { DateTime } from "luxon";
 type EventKey = keyof typeof eventData;
 /**
  * Utilities for skytimes
  */
 export declare class SkytimesUtils {
-    /** Get all occurences of an event for the given date
-     * @param eventTime The moment date for which to get all occurences
-     * @param interval The interval between the event occurence's
+    /** Get all occurrences of an event for the given date
+     * @param eventTime The DateTime for which to get all occurrences
+     * @param interval The interval between the event occurrences
      */
-    static getAllTimes(eventTime: moment.Moment, interval?: number): string;
+    static getAllTimes(eventTime: DateTime, interval?: number): string;
     /**
-     * Get the date in moment on which the event will occur (if it's not a daily event)
+     * Get the date in DateTime on which the event will occur (if it's not a daily event)
      * @param event The event for which to get the date-time
      */
-    private static getOccurenceDay;
+    private static getOccurrenceDay;
     /**
-     * Get the next occurence of the event relative to now
+     * Get the next occurrence of the event relative to now
      * @param eventName The key of the event
      */
     private static getNextEventOccurrence;
     /**
-     * Get the details about an event, their status, next occurence, al occurences for the day
+     * Get the details about an event, their status, next occurrence, all occurrences for the day
      * @param key The event key
      */
     static getEventDetails(key: EventKey): EventDetails;
@@ -34,16 +33,16 @@ export declare class SkytimesUtils {
     /**
      * Returns the event status of a given event
      * @param event The event to get the status for
-     * @param nextOccurence The next occurence of the event relative to "now"
+     * @param nextOccurrence The next occurrence of the event relative to "now"
      * @returns The event status (or null if there is no active duration)
      */
-    static getEventStatus(event: (typeof eventData)[keyof typeof eventData], nextOccurence: moment.Moment): Times;
+    static getEventStatus(event: (typeof eventData)[keyof typeof eventData], nextOccurrence: DateTime): Times;
 }
 export interface BaseTimes {
     /** Whether the event is active or not */
     active: boolean;
     /** The time when the event starts */
-    nextTime: moment.Moment;
+    nextTime: DateTime;
     /** This will be the countdown for when the event ends if it's active,
      *  otherwise it'll be the countdown to the next occurence
      */
@@ -52,21 +51,21 @@ export interface BaseTimes {
 export interface ActiveTimes extends BaseTimes {
     active: true;
     /** The time when the event started if active */
-    startTime: moment.Moment;
+    startTime: DateTime;
     /** The time when the event ends if active */
-    endTime: moment.Moment;
+    endTime: DateTime;
 }
 export interface NotActiveTimes extends BaseTimes {
     active: false;
     /** The time when the event started if active */
-    startTime?: moment.Moment;
+    startTime?: DateTime;
     /** The time when the event ends if active */
-    endTime?: moment.Moment;
+    endTime?: DateTime;
 }
 export type Times = ActiveTimes | NotActiveTimes;
 export interface EventDetails {
     event: (typeof eventData)[EventKey];
-    nextOccurence: moment.Moment;
+    nextOccurence: DateTime;
     allOccurences: string;
     status: Times;
 }

package/dist/classes/SkytimesUtils.js

@@ -1,64 +1,62 @@
-import { Base, time } from "discord.js";
-import moment from "moment-timezone";
-import "moment-duration-format";
 import { eventData } from "../constants/eventDatas.js";
+import { DateTime } from "luxon";
 /**
  * Utilities for skytimes
  */
 export class SkytimesUtils {
-    /** Get all occurences of an event for the given date
-     * @param eventTime The moment date for which to get all occurences
-     * @param interval The interval between the event occurence's
+    /** Get all occurrences of an event for the given date
+     * @param eventTime The DateTime for which to get all occurrences
+     * @param interval The interval between the event occurrences
      */
     static getAllTimes(eventTime, interval) {
-        const clonedTime = eventTime.clone();
+        let clonedTime = eventTime;
         const timeBuilt = [];
-        while (eventTime.date() === clonedTime.date()) {
-            timeBuilt.push(time(clonedTime.toDate(), "t"));
-            clonedTime.add(interval || 0, "minutes");
+        while (eventTime.hasSame(clonedTime, "day")) {
+            timeBuilt.push(`<t:${clonedTime.toUnixInteger()}:t>`);
+            clonedTime = clonedTime.plus({ minutes: interval || 0 });
         }
         return timeBuilt.join(" • ");
     }
     /**
-     * Get the date in moment on which the event will occur (if it's not a daily event)
+     * Get the date in DateTime on which the event will occur (if it's not a daily event)
      * @param event The event for which to get the date-time
      */
-    static getOccurenceDay(event) {
-        const nextOccurrence = moment().tz("America/Los_Angeles").startOf("day").add(event.offset, "minutes"); // Start with the offset from the beginning of the day
+    static getOccurrenceDay(event) {
+        let nextOccurrence = DateTime.now().setZone("America/Los_Angeles").startOf("day").plus({ minutes: event.offset }); // Start with the offset from the beginning of the day
         if (event.occursOn) {
             // If the event occurs on specific weekdays
             if (event.occursOn.weekDays) {
-                while (!event.occursOn.weekDays.includes(nextOccurrence.isoWeekday())) {
-                    nextOccurrence.add(1, "day");
+                while (!event.occursOn.weekDays.includes(nextOccurrence.weekday)) {
+                    nextOccurrence = nextOccurrence.plus({ days: 1 });
                 }
             }
             // If the event occurs on a specific day of the month
             if (event.occursOn.dayOfTheMonth) {
-                while (nextOccurrence.date() !== event.occursOn.dayOfTheMonth) {
-                    nextOccurrence.add(1, "day");
+                while (nextOccurrence.day !== event.occursOn.dayOfTheMonth) {
+                    nextOccurrence = nextOccurrence.plus({ days: 1 });
                 }
             }
         }
         return nextOccurrence;
     }
     /**
-     * Get the next occurence of the event relative to now
+     * Get the next occurrence of the event relative to now
      * @param eventName The key of the event
      */
     static getNextEventOccurrence(eventName) {
         const event = eventData[eventName];
         if (!event)
-            throw new Error("Unknow Event");
-        const now = moment().tz("America/Los_Angeles"); // Current time
-        const nextOccurrence = this.getOccurenceDay(event);
+            throw new Error("Unknown Event");
+        const now = DateTime.now().setZone("America/Los_Angeles"); // Current time
+        let nextOccurrence = this.getOccurrenceDay(event);
         // Loop to calculate the next occurrence based on the interval
-        while (nextOccurrence.isBefore(now)) {
-            nextOccurrence.add(event.interval || 0, "minutes");
+        while (nextOccurrence < now) {
+            nextOccurrence = nextOccurrence.plus({ minutes: event.interval || 0 });
         }
         return nextOccurrence;
     }
     /**
-     * Get the details about an event, their status, next occurence, al occurences for the day
+     * Get the details about an event, their status, next occurrence, all occurrences for the day
      * @param key The event key
      */
     static getEventDetails(key) {
@@ -66,7 +64,7 @@ export class SkytimesUtils {
         return {
             event: eventData[key],
             nextOccurence,
-            allOccurences: this.getAllTimes(this.getOccurenceDay(eventData[key]), eventData[key].interval),
+            allOccurences: this.getAllTimes(this.getOccurrenceDay(eventData[key]), eventData[key].interval),
             status: this.getEventStatus(eventData[key], nextOccurence),
         };
     }
@@ -76,40 +74,39 @@ export class SkytimesUtils {
      */
     static allEventDetails() {
         const keys = Object.keys(eventData).sort((a, b) => eventData[a].index - eventData[b].index);
-        const occurences = [];
+        const occurrences = [];
         for (const key of keys) {
-            occurences.push([key, this.getEventDetails(key)]);
+            occurrences.push([key, this.getEventDetails(key)]);
         }
-        return occurences;
+        return occurrences;
     }
     /**
      * Returns the event status of a given event
      * @param event The event to get the status for
-     * @param nextOccurence The next occurence of the event relative to "now"
+     * @param nextOccurrence The next occurrence of the event relative to "now"
      * @returns The event status (or null if there is no active duration)
      */
-    static getEventStatus(event, nextOccurence) {
-        const now = moment().tz("America/Los_Angeles");
+    static getEventStatus(event, nextOccurrence) {
+        const now = DateTime.now().setZone("America/Los_Angeles");
         const BASE = {
             active: false,
-            nextTime: nextOccurence,
-            duration: moment.duration(nextOccurence.diff(now)).format("d[d] h[h] m[m] s[s]"),
+            nextTime: nextOccurrence,
+            duration: nextOccurrence.diff(now).toFormat("d'd' h'h' m'm' s's'"),
         };
         if (!event.duration)
             return BASE;
-        // Substract the interval because nextOccurence always calculates the next upcoming event
-        // So we substract the interval to get the last occurence, and add the active duration to it, and check if now is between those
-        const start = nextOccurence.clone().subtract(event.interval || 0, "minutes");
-        const end = start.clone().add(event.duration, "minutes");
+        // Subtract the interval because nextOccurrence always calculates the next upcoming event
+        // So we subtract the interval to get the last occurrence, and add the active duration to it, and check if now is between those
+        const start = nextOccurrence.minus({ minutes: event.interval || 0 });
+        const end = start.plus({ minutes: event.duration });
         // When active
-        if (now.isBetween(start, end)) {
+        if (now >= start && now <= end) {
             return {
                 active: true,
                 startTime: start,
                 endTime: end,
-                // TODO: This maybe not needed as nextoccurence is inncluded in original object returned from `eventOccurence()`
-                nextTime: nextOccurence,
-                duration: moment.duration(end.diff(now)).format("d[d] h[h] m[m] s[s]"),
+                nextTime: nextOccurrence,
+                duration: end.diff(now).toFormat("d'd' h'h' m'm' s's'"),
             };
         }
         else {

package/dist/classes/WinnerCard.d.ts

@@ -1,11 +1,11 @@
-import { User, GuildMember, Client } from "discord.js";
+import type { APIGuildMember, APIUser } from "discord-api-types/v10";
 export declare class GameWinnerCard {
+    readonly clientAvatar: string;
     private name;
-    private client;
     private thumbnail;
     private points;
     private total;
-    constructor(winner: User | GuildMember, wins: number, total: number, client: Client);
+    constructor(winner: APIUser | APIGuildMember, wins: number, total: number, clientAvatar: string);
     private path;
     private roundRect;
     private changeFontSize;

package/dist/classes/WinnerCard.js

@@ -1,30 +1,29 @@
 import { createCanvas, loadImage } from "@napi-rs/canvas";
-import { User, GuildMember, Client } from "discord.js";
-import { colors, fancyCount } from "./utils.js";
+import { colors, fancyCount, getUserAvatar } from "./utils.js";
 import { join } from "path";
 const size = 100;
 // TODO: Integrate it with other game types
 export class GameWinnerCard {
+    clientAvatar;
     name;
-    client;
     thumbnail;
     points;
     total;
-    constructor(winner, wins, total, client) {
-        if (winner instanceof User) {
-            this.name = winner?.displayName || winner?.globalName || winner?.username;
-            this.thumbnail = winner?.displayAvatarURL({ forceStatic: true, extension: "jpg" });
+    constructor(winner, wins, total, clientAvatar) {
+        this.clientAvatar = clientAvatar;
+        if ("user" in winner) {
+            this.name = winner.nick || winner.user?.global_name || winner?.user.username;
+            this.thumbnail = getUserAvatar(winner.user);
         }
-        if (winner instanceof GuildMember) {
-            this.name = winner.user?.globalName || winner?.displayName || winner.user.username;
-            this.thumbnail = winner.user?.displayAvatarURL({ forceStatic: true, extension: "jpg" });
+        else {
+            this.name = winner?.global_name || winner?.username;
+            this.thumbnail = getUserAvatar(winner);
         }
-        this.client = client;
         this.points = wins;
         this.total = total;
     }
     path(strs) {
-        return join(__dirname, strs);
+        return join(import.meta.dirname, strs);
     }
     roundRect(ctx, x, y, w, h, r) {
         if (w < 2 * r)
@@ -112,7 +111,7 @@ export class GameWinnerCard {
         ctx.fillStyle = colors.grey;
         this.roundRect(ctx, w * 0.875, h * 0.6, h * 0.4, h * 0.4, h * 0.15).clip();
         ctx.fill();
-        ctx.drawImage(await loadImage(this.client.user.displayAvatarURL({ forceStatic: true, extension: "jpg" })), w * 0.875, h * 0.6, h * 0.4, h * 0.4);
+        ctx.drawImage(await loadImage(this.clientAvatar), w * 0.875, h * 0.6, h * 0.4, h * 0.4);
         return canvas.toBuffer("image/png");
     }
 }

package/dist/classes/index.d.ts

@@ -1,7 +1,5 @@
 export { LeaderboardCard } from "./LeaderBoardCard.js";
 export { GameWinnerCard } from "./WinnerCard.js";
-export { UpdateTS } from "./UpdateTs.js";
-export { UpdateEvent } from "./UpdateEvent.js";
 export { ShardsUtil } from "./shardsUtil.js";
 export { SkytimesUtils } from "./SkytimesUtils.js";
 export * from "./SkytimesUtils.js";

package/dist/classes/index.js

@@ -1,7 +1,5 @@
 export { LeaderboardCard } from "./LeaderBoardCard.js";
 export { GameWinnerCard } from "./WinnerCard.js";
-export { UpdateTS } from "./UpdateTs.js";
-export { UpdateEvent } from "./UpdateEvent.js";
 export { ShardsUtil } from "./shardsUtil.js";
 export { SkytimesUtils } from "./SkytimesUtils.js";
 export * from "./SkytimesUtils.js";

package/dist/classes/shardsUtil.d.ts

@@ -1,5 +1,5 @@
-import moment from "moment-timezone";
 import "moment-duration-format";
+import { DateTime } from "luxon";
 import type { ShardsCountdown } from "../typings.js";
 /**
  * Sequence of Shards pattern
@@ -15,15 +15,15 @@ declare const realmSequence: readonly ["prairie", "forest", "valley", "wasteland
  */
 export declare class ShardsUtil {
     /**
-     * @method getDate - get provided date in moment
+     * @method getDate - get provided date in luxon
      * @param  date - date to get in moment
      */
-    static getDate(date?: string | undefined | null): moment.Moment | string;
+    static getDate(date?: string | undefined | null): DateTime | string;
     /**
      * Returns shards index for a given date
      * @param date
      */
-    static shardsIndex(date: moment.Moment): {
+    static shardsIndex(date: DateTime): {
         currentShard: (typeof shardSequence)[number];
         currentRealm: (typeof realmSequence)[number];
     };
@@ -36,6 +36,6 @@ export declare class ShardsUtil {
      * Get all three shards status for a given date relative to the current time
      * @param date The date for which to get the status for
      */
-    static getStatus(date: moment.Moment): ShardsCountdown[] | "No Shard";
+    static getStatus(date: DateTime): ShardsCountdown[] | "No Shard";
 }
 export {};

package/dist/classes/shardsUtil.js

@@ -1,5 +1,5 @@
-import moment from "moment-timezone";
 import "moment-duration-format";
+import { DateTime } from "luxon";
 import { shardsTimeline, shardConfig } from "../constants/index.js";
 /**
  * Sequence of Shards pattern
@@ -15,7 +15,7 @@ const realmSequence = ["prairie", "forest", "valley", "wasteland", "vault"];
  */
 export class ShardsUtil {
     /**
-     * @method getDate - get provided date in moment
+     * @method getDate - get provided date in luxon
      * @param  date - date to get in moment
      */
     static getDate(date) {
@@ -23,12 +23,13 @@ export class ShardsUtil {
         let currentDate;
         try {
             if (date) {
-                currentDate = moment.tz(date, "Y-MM-DD", timezone).startOf("day");
+                const [year, month, day] = date.split("-").map(Number);
+                currentDate = DateTime.fromObject({ year, month, day }, { zone: timezone }).startOf("day");
             }
             else {
-                currentDate = moment().tz(timezone);
+                currentDate = DateTime.now().setZone(timezone).startOf("day");
             }
-            if (!currentDate.isValid()) {
+            if (!currentDate.isValid) {
                 return "invalid";
             }
             else {
@@ -44,7 +45,7 @@ export class ShardsUtil {
      * @param date
      */
     static shardsIndex(date) {
-        const dayOfMonth = date.date();
+        const dayOfMonth = date.day;
         const shardIndex = (dayOfMonth - 1) % shardSequence.length;
         const currentShard = shardSequence[shardIndex];
         const realmIndex = (dayOfMonth - 1) % realmSequence.length;
@@ -76,43 +77,43 @@ export class ShardsUtil {
         const timezone = "America/Los_Angeles";
         const { currentShard } = this.shardsIndex(date);
         const timings = shardsTimeline(date)[currentShard];
-        const present = moment().tz(timezone);
-        const isNoShard = shardConfig[currentShard].weekdays.includes(date.day());
+        const present = DateTime.now().setZone(timezone);
+        const isNoShard = shardConfig[currentShard].weekdays.includes(date.weekday);
         if (isNoShard)
             return "No Shard";
         const toReturn = [];
         for (let i = 0; i < timings.length; i++) {
             const eventTiming = timings[i];
             // Active
-            if (present.isBetween(eventTiming.start, eventTiming.end)) {
+            if (present >= eventTiming.start && present <= eventTiming.end) {
                 toReturn.push({
                     index: i + 1,
                     active: true,
                     start: eventTiming.start,
                     end: eventTiming.end,
-                    duration: moment.duration(eventTiming.end.diff(present)).format("d[d] h[h] m[m] s[s]"),
+                    duration: eventTiming.end.diff(present, ["days", "hours", "minutes", "seconds"]).toFormat("dd'd' hh'h' mm'm' ss's'"),
                 });
                 continue;
                 // Yet to fall
             }
-            else if (present.isBefore(eventTiming.start)) {
+            else if (present < eventTiming.start) {
                 toReturn.push({
                     index: i + 1,
                     active: false,
                     start: eventTiming.start,
                     end: eventTiming.end,
-                    duration: moment.duration(eventTiming.start.diff(present)).format("d[d] h[h] m[m] s[s]"),
+                    duration: eventTiming.start.diff(present, ["days", "hours", "minutes", "seconds"]).toFormat("dd'd' hh'h' mm'm' ss's'"),
                 });
                 continue;
                 // All ended
             }
-            else if (present.isAfter(eventTiming.end)) {
+            else if (present > eventTiming.end) {
                 toReturn.push({
                     index: i + 1,
                     ended: true,
                     start: eventTiming.start,
                     end: eventTiming.end,
-                    duration: moment.duration(present.diff(eventTiming.end)).format("d[d] h[h] m[m] s[s]"),
+                    duration: present.diff(eventTiming.end, ["days", "hours", "minutes", "seconds"]).toFormat("dd'd' hh'h' mm'm' ss's'"),
                 });
                 continue;
             }

package/dist/classes/utils.d.ts

@@ -1,3 +1,4 @@
+import { type APIUser } from "discord-api-types/v10";
 export declare const colors: {
     blue: string;
     white: string;
@@ -11,3 +12,4 @@ export declare const colors: {
     idle: string;
 };
 export declare function fancyCount(n: number): string;
+export declare function getUserAvatar(user: APIUser): string;

package/dist/classes/utils.js

@@ -1,3 +1,4 @@
+import { CDNRoutes } from "discord-api-types/v10";
 export const colors = {
     blue: "#7289DA",
     white: "#FFFFFF",
@@ -20,3 +21,8 @@ export function fancyCount(n) {
     }
     return Math.floor(n) + "";
 }
+export function getUserAvatar(user) {
+    return user.avatar
+        ? CDNRoutes.userAvatar(user.id, user.avatar, "png")
+        : CDNRoutes.defaultUserAvatar(Number((BigInt(user.id) >> 22n) % 5n));
+}

package/dist/constants/shardsInfo.js

@@ -1,7 +1,7 @@
 export const shardConfig = {
-    a: { type: "<:ShardBlue:1233057106903699497> Black Shard", colors: "#000000", weekdays: [6, 0] },
+    a: { type: "<:ShardBlue:1233057106903699497> Black Shard", colors: "#000000", weekdays: [6, 7] },
     A: { type: "<:ShardRed:1233057065799254106> Red Shard", colors: "#FF0000", weekdays: [2, 3] },
-    b: { type: "<:ShardBlue:1233057106903699497> Black Shard", colors: "#000000", weekdays: [0, 1] },
+    b: { type: "<:ShardBlue:1233057106903699497> Black Shard", colors: "#000000", weekdays: [7, 1] },
     B: { type: "<:ShardRed:1233057065799254106> Red Shard", colors: "#FF0000", weekdays: [3, 4] },
     C: { type: "<:ShardRed:1233057065799254106> Red Shard", colors: "#FF0000", weekdays: [1, 2] },
 };

package/dist/constants/shardsTimeline.d.ts

@@ -1,10 +1,10 @@
-import moment from "moment-timezone";
+import type { DateTime } from "luxon";
 declare const shardSequence: readonly ["C", "b", "A", "a", "B", "b", "C", "a", "A", "b", "B", "a"];
 export type TimelineType = {
-    readonly earlySky: moment.Moment;
-    readonly gateShard: moment.Moment;
-    readonly start: moment.Moment;
-    readonly end: moment.Moment;
+    readonly earlySky: DateTime;
+    readonly gateShard: DateTime;
+    readonly start: DateTime;
+    readonly end: DateTime;
     readonly shardMusic: string;
 };
 export type TimelineReturnType = Record<(typeof shardSequence)[number], [TimelineType, TimelineType, TimelineType]>;
@@ -15,5 +15,5 @@ export type TimelineReturnType = Record<(typeof shardSequence)[number], [Timelin
  * const timelines = shardsTimeline(moment())
  * const times = timelines[currentShard]
  */
-export declare const shardsTimeline: (currentDate: moment.Moment) => TimelineReturnType;
+export declare const shardsTimeline: (currentDate: DateTime) => TimelineReturnType;
 export {};

package/dist/constants/shardsTimeline.js

@@ -1,4 +1,3 @@
-import moment from "moment-timezone";
 const shardSequence = ["C", "b", "A", "a", "B", "b", "C", "a", "A", "b", "B", "a"];
 /**
  * Returns shards fall - end times for a given date
@@ -10,20 +9,10 @@ const shardSequence = ["C", "b", "A", "a", "B", "b", "C", "a", "A", "b", "B", "a
 export const shardsTimeline = (currentDate) => {
     const getTimes = (earlySkyHours, earlySkyMinutes, earlySkySeconds, gateShardHours, gateShardMinutes, shardLandHours, shardLandMinutes, shardLandSeconds, shardEndHours, shardEndMinutes, shardMusic) => {
         return {
-            earlySky: currentDate
-                .clone()
-                .startOf("day")
-                .add(earlySkyHours, "hours")
-                .add(earlySkyMinutes, "minutes")
-                .add(earlySkySeconds, "seconds"),
-            gateShard: currentDate.clone().startOf("day").add(gateShardHours, "hours").add(gateShardMinutes, "minutes"),
-            start: currentDate
-                .clone()
-                .startOf("day")
-                .add(shardLandHours, "hours")
-                .add(shardLandMinutes, "minutes")
-                .add(shardLandSeconds, "seconds"),
-            end: currentDate.clone().startOf("day").add(shardEndHours, "hours").add(shardEndMinutes, "minutes"),
+            earlySky: currentDate.startOf("day").plus({ hours: earlySkyHours, minutes: earlySkyMinutes, seconds: earlySkySeconds }),
+            gateShard: currentDate.startOf("day").plus({ hours: gateShardHours, minutes: gateShardMinutes }),
+            start: currentDate.startOf("day").plus({ hours: shardLandHours, minutes: shardLandMinutes, seconds: shardLandSeconds }),
+            end: currentDate.startOf("day").plus({ hours: shardEndHours, minutes: shardEndMinutes }),
             shardMusic: shardMusic,
         };
     };

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { buildTimesHTML, parsePerms, postToHaste, recursiveReadDir, type Field, parseDateFormat } from "./utils/index.js";
+export * from "./utils/index.js";
 export * from "./classes/index.js";
 export { type Permission } from "./utils/parsePerms.js";
-export { buildTimesHTML, parsePerms, postToHaste, parseDateFormat, type Field, recursiveReadDir };
 export * from "./constants/index.js";
 export type * from "./typings.ts";

package/dist/index.js

@@ -1,5 +1,4 @@
-import { buildTimesHTML, parsePerms, postToHaste, recursiveReadDir, parseDateFormat } from "./utils/index.js";
+export * from "./utils/index.js";
 export * from "./classes/index.js";
 export {} from "./utils/parsePerms.js";
-export { buildTimesHTML, parsePerms, postToHaste, parseDateFormat, recursiveReadDir };
 export * from "./constants/index.js";

package/dist/typings.d.ts

@@ -1,5 +1,4 @@
-import { Client, Collection } from "discord.js";
-import moment from "moment-timezone";
+import type { DateTime } from "luxon";
 import { Document } from "mongoose";
 /** Data of users provided for making a game leaderboard card */
 export interface userData {
@@ -34,13 +33,10 @@ export interface Background {
 export interface SkyEvent {
     eventActive: Boolean;
     eventName: string;
-    eventStarts: moment.Moment;
-    eventEnds: moment.Moment;
+    eventStarts: DateTime;
+    eventEnds: DateTime;
     eventDuration: string;
 }
-export interface SkyHelper extends Client {
-    skyEvents: Collection<string, SkyEvent>;
-}
 export interface TSData extends Document {
     name: string;
     visitDate: string;
@@ -56,7 +52,7 @@ export interface ShardsCountdown {
     index: number;
     active?: boolean;
     ended?: boolean;
-    start: moment.Moment;
-    end: moment.Moment;
+    start: DateTime;
+    end: DateTime;
     duration: string;
 }

package/dist/typings.js

@@ -1,3 +1 @@
-import { Client, Collection } from "discord.js";
-import moment from "moment-timezone";
 import { Document } from "mongoose";

package/dist/utils/index.d.ts

@@ -1,5 +1,5 @@
-export { buildTimesHTML, type Field } from "./buildTimesHTML.js";
-export { postToHaste } from "./postToBin.js";
-export { parsePerms, type Permission } from "./parsePerms.js";
-export { recursiveReadDir } from "./recursiveReadDir.js";
-export { parseDateFormat } from "./parseDateFormat.js";
+export * from "./postToBin.js";
+export * from "./parsePerms.js";
+export * from "./recursiveReadDir.js";
+export * from "./parseDateFormat.js";
+export * from "./resolveColors.js";

package/dist/utils/index.js

@@ -1,5 +1,5 @@
-export { buildTimesHTML } from "./buildTimesHTML.js";
-export { postToHaste } from "./postToBin.js";
-export { parsePerms } from "./parsePerms.js";
-export { recursiveReadDir } from "./recursiveReadDir.js";
-export { parseDateFormat } from "./parseDateFormat.js";
+export * from "./postToBin.js";
+export * from "./parsePerms.js";
+export * from "./recursiveReadDir.js";
+export * from "./parseDateFormat.js";
+export * from "./resolveColors.js";

package/dist/utils/resolveColors.d.ts

@@ -0,0 +1,79 @@
+/** Original code credit to discord.js */
+/**
+ * Can be a number, hex string, an RGB array like:
+ * ```js
+ * [255, 0, 255] // purple
+ * ```
+ * or one of the following strings:
+ * - `Default`
+ * - `White`
+ * - `Aqua`
+ * - `Green`
+ * - `Blue`
+ * - `Yellow`
+ * - `Purple`
+ * - `LuminousVividPink`
+ * - `Fuchsia`
+ * - `Gold`
+ * - `Orange`
+ * - `Red`
+ * - `Grey`
+ * - `Navy`
+ * - `DarkAqua`
+ * - `DarkGreen`
+ * - `DarkBlue`
+ * - `DarkPurple`
+ * - `DarkVividPink`
+ * - `DarkGold`
+ * - `DarkOrange`
+ * - `DarkRed`
+ * - `DarkGrey`
+ * - `DarkerGrey`
+ * - `LightGrey`
+ * - `DarkNavy`
+ * - `Blurple`
+ * - `Greyple`
+ * - `DarkButNotBlack`
+ * - `NotQuiteBlack`
+ * - `Random`
+ */
+export type ColorResolvable = keyof typeof Colors | "Random" | "Default" | `#${string}` | number | number[];
+/**
+ * Resolves a ColorResolvable into a color number.
+ * @param  color Color to resolve
+ * @returns  A color
+ */
+export declare function resolveColor(color: ColorResolvable): number;
+declare const Colors: {
+    Default: number;
+    White: number;
+    Aqua: number;
+    Green: number;
+    Blue: number;
+    Yellow: number;
+    Purple: number;
+    LuminousVividPink: number;
+    Fuchsia: number;
+    Gold: number;
+    Orange: number;
+    Red: number;
+    Grey: number;
+    Navy: number;
+    DarkAqua: number;
+    DarkGreen: number;
+    DarkBlue: number;
+    DarkPurple: number;
+    DarkVividPink: number;
+    DarkGold: number;
+    DarkOrange: number;
+    DarkRed: number;
+    DarkGrey: number;
+    DarkerGrey: number;
+    LightGrey: number;
+    DarkNavy: number;
+    Blurple: number;
+    Greyple: number;
+    DarkButNotBlack: number;
+    NotQuiteBlack: number;
+};
+export {};

package/dist/utils/resolveColors.js

@@ -0,0 +1,63 @@
+/** Original code credit to discord.js */
+/**
+ * Resolves a ColorResolvable into a color number.
+ * @param  color Color to resolve
+ * @returns  A color
+ */
+export function resolveColor(color) {
+    let resolvedColor;
+    if (typeof color === "string") {
+        if (color === "Random")
+            return Math.floor(Math.random() * (0xffffff + 1));
+        if (color === "Default")
+            return 0;
+        if (/^#?[\da-f]{6}$/i.test(color))
+            return parseInt(color.replace("#", ""), 16);
+        resolvedColor = Colors[color];
+    }
+    else if (Array.isArray(color)) {
+        resolvedColor = (color[0] << 16) + (color[1] << 8) + color[2];
+    }
+    else {
+        resolvedColor = color;
+    }
+    if (!Number.isInteger(resolvedColor)) {
+        throw new Error("Not a number");
+    }
+    if (resolvedColor < 0 || resolvedColor > 0xffffff) {
+        throw new Error("Not in color range");
+    }
+    return resolvedColor;
+}
+const Colors = {
+    Default: 0x000000,
+    White: 0xffffff,
+    Aqua: 0x1abc9c,
+    Green: 0x57f287,
+    Blue: 0x3498db,
+    Yellow: 0xfee75c,
+    Purple: 0x9b59b6,
+    LuminousVividPink: 0xe91e63,
+    Fuchsia: 0xeb459e,
+    Gold: 0xf1c40f,
+    Orange: 0xe67e22,
+    Red: 0xed4245,
+    Grey: 0x95a5a6,
+    Navy: 0x34495e,
+    DarkAqua: 0x11806a,
+    DarkGreen: 0x1f8b4c,
+    DarkBlue: 0x206694,
+    DarkPurple: 0x71368a,
+    DarkVividPink: 0xad1457,
+    DarkGold: 0xc27c0e,
+    DarkOrange: 0xa84300,
+    DarkRed: 0x992d22,
+    DarkGrey: 0x979c9f,
+    DarkerGrey: 0x7f8c8d,
+    LightGrey: 0xbcc0c0,
+    DarkNavy: 0x2c3e50,
+    Blurple: 0x5865f2,
+    Greyple: 0x99aab5,
+    DarkButNotBlack: 0x2c2f33,
+    NotQuiteBlack: 0x23272a,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyhelperbot/utils",
-  "version": "2.0.1",
+  "version": "2.0.2-dev",
   "description": "Utilities for SkyHelper bot",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,16 +27,20 @@
   "homepage": "https://github.com/imnaiyar/skyhelper/packages/utils#readme",
   "dependencies": {
     "@napi-rs/canvas": "^0.1.51",
-    "discord.js": "^14.14.1",
+    "discord-api-types": "^0.37.93",
     "moment-duration-format": "^2.3.2",
-    "moment-timezone": "^0.5.45",
     "typescript": "^5.4.3",
-    "undici": "^6.13.0"
+    "undici": "^7.2.3"
   },
   "devDependencies": {
+    "@types/luxon": "^3.4.2",
     "@types/moment-duration-format": "^2.2.6",
+    "luxon": "^3.5.0",
     "mongoose": "^8.3.2"
   },
+  "peerDependencies": {
+    "luxon": "^3.5.0"
+  },
   "scripts": {
     "build": "tsc && echo 'Files compiled'",
     "build:docs": "typedoc"