@skyhelperbot/utils 2.0.2 → 2.1.1

package/dist/classes/LeaderBoardCard.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import type { userData, colorsType, LeaderboardOptions } from "../typings.js";
 /**
  * Represents a Quiz Leaderboard Card. A class for generating a leaderboard card for a quiz or game.

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,13 @@
-import { User, GuildMember, Client } from "discord.js";
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+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,4 @@
-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 +14,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 +35,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,4 @@
-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 +14,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 +22,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 +44,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 +76,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";