@kyvrixon/utils 0.0.6 → 1.0.10

package/README.md

@@ -1,7 +1,9 @@
-# Utils
-
-General utility files I use for alot of projects! Does not include any larger scale items, just the little things
-
-```bash
-bun install @kyvrixon/utils@latest
-```
+# @kyvrixon/utils
+
+General utility files I use for alot of projects! Designed for use with the [bun runtime](https://bun.sh/)!
+
+```bash
+bun install @kyvrixon/utils
+# or
+bun install github:kyvrixon/utils#1.0.10
+```

package/package.json

@@ -1,31 +1,38 @@
 {
-  "name": "@kyvrixon/utils",
-  "main": "./src/index.ts",
-  "version": "0.0.6",
-  "type": "module",
-  "private": false,
-  "license": "MIT",
-  "files": [
-    "src"
-  ],
-  "scripts": {
-    "pub": "bun publish --access public"
-  },
-  "packageManager": "bun@1.3.6",
-  "types": "./src/index.ts",
-  "devDependencies": {
-    "@types/bun": "1.3.6"
-  },
-  "peerDependencies": {
-    "typescript": "^5.9.3"
-  },
-  "dependencies": {
-    "chalk": "^5.6.2"
-  },
-  "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
-    }
-  }
+	"name": "@kyvrixon/utils",
+	"main": "./src/index.ts",
+	"version": "1.0.10",
+	"type": "module",
+	"private": false,
+	"license": "MIT",
+	"files": [
+		"src"
+	],
+	"engines": {
+		"bun": "1.3.10"
+	},
+	"repository": {
+		"url": "https://github.com/kyvrixon/utils"
+	},
+	"scripts": {
+		"pub": "bun prebuild.ts && bun publish --access public",
+		"pretty": "bun biome format --write ."
+	},
+	"packageManager": "bun@1.3.10",
+	"types": "./src/index.ts",
+	"devDependencies": {
+		"@biomejs/biome": "2.4.6",
+		"@types/bun": "1.3.10",
+		"typescript": "5.9.3"
+	},
+	"dependencies": {
+		"chalk": "5.6.2",
+		"discord.js": "14.25.1"
+	},
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts"
+		}
+	}
 }

package/src/index.ts

@@ -1,3 +1,6 @@
 export * from "./lib/formatSeconds";
-export * from "./lib/logger";
-export * from "./lib/toOrdinal";
+export * from "./lib/toOrdinal";
+export * from "./lib/discord-utils/Command";
+export * from "./lib/discord-utils/createPagination";
+export * from "./lib/discord-utils/Event";
+export * from "./lib/modules/LoggerModule";

package/src/lib/discord-utils/Command.ts

@@ -0,0 +1,33 @@
+import type {
+	AutocompleteInteraction,
+	ChatInputCommandInteraction,
+	Client,
+	SlashCommandBuilder,
+	SlashCommandOptionsOnlyBuilder,
+	SlashCommandSubcommandsOnlyBuilder,
+} from "discord.js";
+
+export class DiscordCommand<C extends Client<boolean>> {
+	public readonly data:
+		| SlashCommandBuilder
+		| SlashCommandOptionsOnlyBuilder
+		| SlashCommandSubcommandsOnlyBuilder;
+	public readonly execute: (
+		client: C,
+		interaction: ChatInputCommandInteraction,
+	) => Promise<void>;
+	public readonly autocomplete?: (
+		client: C,
+		interaction: AutocompleteInteraction,
+	) => Promise<void>;
+
+	constructor(ops: {
+		data: DiscordCommand<C>["data"];
+		execute: DiscordCommand<C>["execute"];
+		autocomplete?: DiscordCommand<C>["autocomplete"];
+	}) {
+		this.data = ops.data;
+		this.execute = ops.execute;
+		this.autocomplete = ops.autocomplete;
+	}
+}

package/src/lib/discord-utils/Event.ts

@@ -0,0 +1,61 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: Its fine */
+import type { Client, ClientEvents, RestEvents } from "discord.js";
+
+// biome-ignore lint/suspicious/noEmptyInterface: Its fine
+export interface DiscordEventCustomType {}
+/**
+ * To define custom types:
+ * @example
+ * declare module "@kyvrixon/utils" {
+ * 	interface DiscordEventCustomType {
+ *			myEventName: [data: string];
+ *		}
+ * }
+ * // You can also add these to `ClientEvents` if you wish for better typing like so:
+ * declare module "discord.js" {
+ * 	interface ClientEvents extends DiscordEventCustomType {}
+ * }
+ */
+export class DiscordEvent<
+	V extends Client,
+	T extends "client" | "custom" | "rest" = "client",
+	K extends T extends "custom"
+		? keyof DiscordEventCustomType
+		: T extends "client"
+			? keyof ClientEvents
+			: keyof RestEvents = T extends "custom"
+		? keyof DiscordEventCustomType
+		: T extends "client"
+			? keyof ClientEvents
+			: keyof RestEvents,
+> {
+	public readonly type: T;
+	public readonly name: K;
+	public readonly once: boolean;
+	public readonly method: (
+		client: V,
+		...args: T extends "client"
+			? K extends keyof ClientEvents
+				? ClientEvents[K]
+				: any[]
+			: T extends "rest"
+				? K extends keyof RestEvents
+					? RestEvents[K]
+					: any[]
+				: K extends keyof DiscordEventCustomType
+					? DiscordEventCustomType[K]
+					: any[]
+	) => Promise<void>;
+
+	constructor(opts: {
+		type: T;
+		name: K;
+		once?: boolean;
+		method: DiscordEvent<V, T, K>["method"];
+	}) {
+		this.type = opts.type;
+		this.name = opts.name;
+		this.once = opts.once ?? false;
+		this.method = opts.method;
+	}
+}

package/src/lib/discord-utils/createPagination.ts

@@ -0,0 +1,327 @@
+import { randomUUIDv7 } from "bun";
+import {
+	ActionRowBuilder,
+	ButtonBuilder,
+	type ButtonInteraction,
+	ButtonStyle,
+	type ChannelSelectMenuBuilder,
+	type ChatInputCommandInteraction,
+	ComponentType,
+	ContainerBuilder,
+	type FileBuilder,
+	LabelBuilder,
+	type MediaGalleryBuilder,
+	type MentionableSelectMenuBuilder,
+	ModalBuilder,
+	type RoleSelectMenuBuilder,
+	type SectionBuilder,
+	type SeparatorBuilder,
+	type StringSelectMenuBuilder,
+	TextDisplayBuilder,
+	TextInputBuilder,
+	TextInputStyle,
+	type UserSelectMenuBuilder,
+} from "discord.js";
+
+export type MessageActionRow = ActionRowBuilder<
+	| ButtonBuilder
+	| StringSelectMenuBuilder
+	| UserSelectMenuBuilder
+	| RoleSelectMenuBuilder
+	| ChannelSelectMenuBuilder
+	| MentionableSelectMenuBuilder
+>;
+
+export type LeaderboardComponentType =
+	| { type: "buttons" }
+	| { type: "display"; component: TextDisplayBuilder }
+	| { type: "section"; component: SectionBuilder }
+	| { type: "separator"; component: SeparatorBuilder }
+	| { type: "file"; component: FileBuilder }
+	| { type: "gallery"; component: MediaGalleryBuilder }
+	| { type: "actionrow"; component: MessageActionRow };
+
+export interface LeaderboardOptions {
+	contentMarker?: string;
+	entriesPerPage?: number;
+	replacements?: Record<string, string>;
+	styling?: Array<{ accent_color?: number; spoiler?: boolean }>;
+	ephemeral?: boolean;
+}
+
+function applyReplacements(
+	content: string,
+	replacements?: Record<string, string>,
+): string {
+	if (!replacements) return content;
+	return Object.entries(replacements).reduce(
+		(acc, [key, value]) => acc.replaceAll(key, value),
+		content,
+	);
+}
+
+function getPaginationRow(
+	prefix: string,
+	currentIndex: number,
+	entriesPerPage: number,
+	totalPages: number,
+	listLength: number,
+	ended: boolean,
+): ActionRowBuilder<ButtonBuilder> {
+	return new ActionRowBuilder<ButtonBuilder>().addComponents(
+		new ButtonBuilder()
+			.setCustomId(`${prefix}back`)
+			.setLabel("Prev")
+			.setStyle(ButtonStyle.Secondary)
+			.setDisabled(ended || currentIndex === 0),
+		new ButtonBuilder()
+			.setCustomId(`${prefix}info`)
+			.setLabel(
+				`${Math.floor(currentIndex / entriesPerPage) + 1}/${totalPages}`,
+			)
+			.setStyle(ButtonStyle.Secondary)
+			.setDisabled(ended || totalPages === 1),
+		new ButtonBuilder()
+			.setCustomId(`${prefix}forward`)
+			.setLabel("Next")
+			.setStyle(ButtonStyle.Secondary)
+			.setDisabled(ended || currentIndex + entriesPerPage >= listLength),
+	);
+}
+
+export async function createPagination(
+	list: Array<string>,
+	structure: Array<Array<LeaderboardComponentType>>,
+	interaction: ButtonInteraction | ChatInputCommandInteraction,
+	options: LeaderboardOptions = {},
+) {
+	const {
+		entriesPerPage = 5,
+		replacements,
+		styling,
+		ephemeral = false,
+		contentMarker = "--DATA_INPUT--",
+	} = options;
+
+	if (entriesPerPage <= 0)
+		throw new Error("entriesPerPage must be greater than 0");
+
+	const uID = randomUUIDv7();
+	const prefix = `~PAGINATION_${uID}_`;
+	let currentIndex = 0;
+	let ended = false;
+
+	if (!list.length) {
+		await interaction
+			.reply({
+				allowedMentions: {
+					parse: [],
+					repliedUser: false,
+				},
+				components: [
+					new ContainerBuilder().addTextDisplayComponents(
+						new TextDisplayBuilder().setContent("No data to show"),
+					),
+				],
+				flags: ephemeral ? ["Ephemeral", "IsComponentsV2"] : ["IsComponentsV2"],
+			})
+			.catch(() => {});
+		return;
+	}
+
+	const totalPages = Math.ceil(list.length / entriesPerPage);
+	const lastPage = structure[structure.length - 1];
+
+	if (!lastPage) throw new Error("createLeaderboard is in a corrupted state");
+
+	while (structure.length < totalPages) {
+		structure.push(
+			lastPage.map((comp) => {
+				if (comp.type === "display") {
+					return {
+						type: "display",
+						component: new TextDisplayBuilder(comp.component.toJSON()),
+					};
+				}
+				return comp;
+			}),
+		);
+	}
+
+	function generateContainer(page: number): ContainerBuilder {
+		const pageStructure = structure[page];
+		if (!pageStructure) throw new Error(`Page ${page} structure not found`);
+
+		return new ContainerBuilder({
+			components: pageStructure.map((comp) => {
+				switch (comp.type) {
+					case "buttons":
+						return getPaginationRow(
+							prefix,
+							currentIndex,
+							entriesPerPage,
+							totalPages,
+							list.length,
+							ended,
+						).toJSON();
+
+					case "display": {
+						if (comp.component.data.content !== contentMarker) {
+							return comp.component.toJSON();
+						}
+
+						const content = list
+							.slice(
+								page * entriesPerPage,
+								page * entriesPerPage + entriesPerPage,
+							)
+							.join("\n");
+						comp.component.data.content = applyReplacements(
+							content,
+							replacements,
+						);
+						return comp.component.toJSON();
+					}
+
+					case "section":
+					case "separator":
+					case "file":
+					case "gallery":
+					case "actionrow":
+						return comp.component.toJSON();
+
+					default: {
+						return comp;
+					}
+				}
+			}),
+			accent_color: styling?.[page]?.accent_color,
+			spoiler: styling?.[page]?.spoiler,
+		});
+	}
+
+	if (!interaction.replied && !interaction.deferred) {
+		await interaction
+			.deferReply({
+				withResponse: true,
+				flags: ephemeral ? ["Ephemeral"] : [],
+			})
+			.catch(() => null);
+	}
+
+	const channel = interaction.channel;
+	if (!channel || !("createMessageComponentCollector" in channel)) {
+		throw new Error("Invalid channel type");
+	}
+
+	async function render(): Promise<void> {
+		try {
+			await interaction.editReply({
+				components: [
+					generateContainer(Math.floor(currentIndex / entriesPerPage)),
+				],
+				flags: ["IsComponentsV2"],
+				allowedMentions: {
+					parse: [],
+					repliedUser: false,
+				},
+			});
+		} catch (error) {
+			const e = error as Error;
+			if (!e.message.includes("Unknown Message")) {
+				console.error("Failed to render leaderboard:", error);
+			}
+		}
+	}
+
+	await render();
+
+	const collector = channel.createMessageComponentCollector({
+		componentType: ComponentType.Button,
+		time: 60000,
+	});
+
+	collector.on("collect", async (btn) => {
+		if (btn.user.id !== interaction.user.id) {
+			return void btn.deferUpdate();
+		}
+
+		if (!btn.customId.startsWith(prefix)) return;
+
+		ended = false;
+		collector.resetTimer();
+
+		if (btn.customId === `${prefix}info`) {
+			const modal = new ModalBuilder()
+				.setCustomId(`${prefix}modal`)
+				.setTitle("Page Indexer")
+				.addLabelComponents(
+					new LabelBuilder()
+						// .setDescription("Input a page number")
+						.setLabel("Input a page number")
+						.setTextInputComponent(
+							new TextInputBuilder()
+								.setCustomId(`${prefix}number`)
+								.setRequired(true)
+								.setMinLength(1)
+								.setStyle(TextInputStyle.Short),
+						),
+				);
+
+			await btn.showModal(modal).catch((e) => console.error(e));
+			const modalSubmit = await btn
+				.awaitModalSubmit({ time: 60_000 })
+				.catch((e) => console.error(e));
+
+			if (!modalSubmit) {
+				await btn
+					.followUp({
+						content: "Modal timed out.",
+						flags: ["Ephemeral"],
+					})
+					.catch(() => null);
+				return;
+			}
+
+			await modalSubmit.deferUpdate().catch(() => null);
+			const pageNumber = Number(
+				modalSubmit.fields.getTextInputValue(`${prefix}number`),
+			);
+
+			if (
+				Number.isNaN(pageNumber) ||
+				pageNumber < 1 ||
+				pageNumber > totalPages
+			) {
+				await modalSubmit
+					.reply({
+						content: `Invalid page! Choose a number between **1** and **${totalPages}**.`,
+						flags: ["Ephemeral"],
+						allowedMentions: {
+							parse: [],
+							repliedUser: false,
+						},
+					})
+					.catch(() => null);
+				return;
+			}
+
+			currentIndex = (pageNumber - 1) * entriesPerPage;
+		} else {
+			currentIndex +=
+				btn.customId === `${prefix}back` ? -entriesPerPage : entriesPerPage;
+			currentIndex = Math.max(
+				0,
+				Math.min(currentIndex, (totalPages - 1) * entriesPerPage),
+			);
+			await btn.deferUpdate().catch(() => {});
+		}
+
+		await render();
+	});
+
+	collector.on("end", async () => {
+		ended = true;
+		await render();
+	});
+}

package/src/lib/formatSeconds.ts

@@ -4,12 +4,12 @@ const UNITS: Record<
 	TimeUnitTypes,
 	{ label: string; short: string; ms: number }
 > = {
-	y: { label: "year", short: "y", ms: 0 },
-	mo: { label: "month", short: "mo", ms: 0 },
-	w: { label: "week", short: "w", ms: 7 * 24 * 3600 * 1000 },
-	d: { label: "day", short: "d", ms: 24 * 3600 * 1000 },
-	h: { label: "hour", short: "h", ms: 3600 * 1000 },
-	m: { label: "minute", short: "m", ms: 60 * 1000 },
+	y: { label: "year", short: "y", ms: 31536000000 },
+	mo: { label: "month", short: "mo", ms: 2628000000 },
+	w: { label: "week", short: "w", ms: 604800000 },
+	d: { label: "day", short: "d", ms: 86400000 },
+	h: { label: "hour", short: "h", ms: 3600000 },
+	m: { label: "minute", short: "m", ms: 60000 },
 	s: { label: "second", short: "s", ms: 1000 },
 	ms: { label: "millisecond", short: "ms", ms: 1 },
 };
@@ -25,13 +25,6 @@ const ALL_UNITS_ORDER: Array<TimeUnitTypes> = [
 	"ms",
 ];
 
-/**
- * Format a number to a customisable and readable time string
- * 
- * @param seconds Number in seconds to format
- * @param options Options for formatting
- * @returns string
- */
 export function formatSeconds(
 	seconds: number,
 	options: {
@@ -45,98 +38,80 @@ export function formatSeconds(
 		) => string;
 	} = {},
 ): string {
-	const includeZeroUnits = options.includeZeroUnits ?? false;
-	const onlyUnits = options.onlyUnits ?? [];
-	const format = options.format ?? "long";
-	const customFormatter = options.customFormatter;
-
-	const totalMs = Math.max(0, Number(seconds) * 1000);
+	const {
+		includeZeroUnits = false,
+		onlyUnits = [],
+		format = "long",
+		customFormatter,
+	} = options;
+	let totalMs = Math.max(0, Math.round(seconds * 1000));
 	const unitsToDisplay = ALL_UNITS_ORDER.filter((u) =>
 		onlyUnits.length ? onlyUnits.includes(u) : true,
 	);
 
-	if (totalMs === 0) {
-		const zeroParts: Array<string> = [];
-		for (const u of unitsToDisplay) {
-			if (format === "short") {
-				zeroParts.push(`0${UNITS[u].short}`);
-			} else {
-				zeroParts.push(`0 ${UNITS[u].label}`);
-			}
-		}
-		return zeroParts.join(format === "short" ? " " : ", ");
-	}
-
+	const diff: Partial<Record<TimeUnitTypes, number>> = {};
 	const now = new Date();
 	const end = new Date(now.getTime() + totalMs);
 
-	let years = 0;
-	if (unitsToDisplay.includes("y") || unitsToDisplay.includes("mo")) {
-		years = end.getFullYear() - now.getFullYear();
+	if (unitsToDisplay.includes("y")) {
+		let y = end.getFullYear() - now.getFullYear();
+		const tempDate = new Date(now);
+		tempDate.setFullYear(now.getFullYear() + y);
+		if (tempDate > end) y--;
+		diff.y = y;
+		totalMs -= new Date(now).setFullYear(now.getFullYear() + y) - now.getTime();
 	}
 
-	let months = 0;
 	if (unitsToDisplay.includes("mo")) {
-		months = end.getMonth() - now.getMonth();
-		if (years < 0) months += 12;
-	}
+		const startTotalMonths = now.getFullYear() * 12 + now.getMonth();
+		const endTotalMonths = end.getFullYear() * 12 + end.getMonth();
+		let mo = endTotalMonths - startTotalMonths;
+		if (diff.y) mo -= diff.y * 12;
 
-	const remainingMs =
-		end.getTime() -
-		new Date(
-			now.getFullYear() + years,
-			now.getMonth() + months,
-			now.getDate(),
-			now.getHours(),
-			now.getMinutes(),
-			now.getSeconds(),
-			now.getMilliseconds(),
-		).getTime();
+		const tempDate = new Date(now);
+		tempDate.setFullYear(now.getFullYear() + (diff.y || 0));
+		tempDate.setMonth(now.getMonth() + mo);
+		if (tempDate > end) mo--;
 
-	const diff: Record<TimeUnitTypes, number> = {
-		y: years,
-		mo: months,
-		w: Math.floor(remainingMs / UNITS.w.ms),
-		d: Math.floor((remainingMs % UNITS.w.ms) / UNITS.d.ms),
-		h: Math.floor((remainingMs % UNITS.d.ms) / UNITS.h.ms),
-		m: Math.floor((remainingMs % UNITS.h.ms) / UNITS.m.ms),
-		s: Math.floor((remainingMs % UNITS.m.ms) / UNITS.s.ms),
-		ms: remainingMs % 1000,
-	};
+		diff.mo = Math.max(0, mo);
+		const jumpDate = new Date(now);
+		jumpDate.setFullYear(now.getFullYear() + (diff.y || 0));
+		jumpDate.setMonth(now.getMonth() + (diff.mo || 0));
+		totalMs = end.getTime() - jumpDate.getTime();
+	}
 
-	const showZeros = includeZeroUnits || onlyUnits.length > 0;
+	for (const unit of ["w", "d", "h", "m", "s", "ms"] as const) {
+		if (unitsToDisplay.includes(unit)) {
+			diff[unit] = Math.floor(totalMs / UNITS[unit].ms);
+			totalMs %= UNITS[unit].ms;
+		}
+	}
 
-	const parts: Array<string> = [];
+	const parts: string[] = [];
 	for (const unit of unitsToDisplay) {
 		const value = diff[unit] ?? 0;
-		if (value || showZeros) {
-			let label = "";
-			if (format === "short") {
-				label = UNITS[unit].short;
-			} else {
-				if (value === 1) {
-					label = UNITS[unit].label;
-				} else {
-					label = `${UNITS[unit].label}s`;
-				}
-			}
+		if (value > 0 || includeZeroUnits) {
+			const label =
+				format === "short"
+					? UNITS[unit].short
+					: value === 1
+						? UNITS[unit].label
+						: `${UNITS[unit].label}s`;
 
-			if (customFormatter) {
-				parts.push(customFormatter(unit, value, label));
-			} else {
-				if (format === "short") {
-					parts.push(`${value}${label}`);
-				} else {
-					parts.push(`${value} ${label}`);
-				}
-			}
+			parts.push(
+				customFormatter
+					? customFormatter(unit, value, label)
+					: format === "short"
+						? `${value}${label}`
+						: `${value} ${label}`,
+			);
 		}
 	}
 
+	if (parts.length === 0) return format === "short" ? "0s" : "0 seconds";
 	if (format === "long" && parts.length > 1) {
 		const last = parts.pop();
 		return `${parts.join(", ")} and ${last}`;
 	}
-
-	return parts.join(format === "short" ? " " : ",");
+	return parts.join(format === "short" ? " " : ", ");
 }

package/src/lib/modules/LoggerModule.ts

@@ -0,0 +1,96 @@
+import chalk from "chalk";
+
+type LogLevel = "notif" | "alert" | "error" | "debug";
+const { cyan, yellow, red, magenta, dim, gray, bold } = chalk;
+const formatter = new Intl.DateTimeFormat("en-AU", {
+	weekday: "short",
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: false,
+});
+
+export class LoggerModule {
+	private readonly colors: Record<LogLevel, typeof chalk> = {
+		notif: cyan,
+		alert: yellow,
+		error: red,
+		debug: magenta,
+	};
+
+	private readonly logMethods: Record<
+		LogLevel,
+		"log" | "warn" | "error" | "debug"
+	> = {
+		notif: "log",
+		alert: "warn",
+		error: "error",
+		debug: "debug",
+	};
+
+	private getTimestamp(): string {
+		const d = new Date();
+		return `${formatter.format(d)}.${d.getMilliseconds().toString().padStart(3, "0")}`;
+	}
+
+	private formatMessage(level: LogLevel, message: unknown): string {
+		const timestamp = gray(`[${this.getTimestamp()}]`);
+		const levelLabel = bold(this.colors[level](level.toUpperCase().padEnd(5)));
+
+		const content =
+			message instanceof Error
+				? `${red(message.message)}\n${this.sanitizeStack(message.stack || "")}`
+				: String(message);
+
+		return `${timestamp} ${levelLabel} ${dim("»")} ${content}`;
+	}
+
+	private sanitizeStack(stack: string): string {
+		return stack
+			.split("\n")
+			.slice(1)
+			.filter((line) => line.includes(":") && !line.includes("node_modules"))
+			.map((line) => {
+				return line
+					.trim()
+					.replace(/\\/g, "/")
+					.replace(
+						/at\s+(.+?)\s+\((.+):(\d+):(\d+)\)/,
+						(_, fn, f, l, c) => `  └─ ${fn} ${dim(f)} ${bold(`(L${l} C${c})`)}`,
+					)
+					.replace(
+						/at\s+(.+):(\d+):(\d+)/,
+						(_, f, l, c) => `  └─ ${dim(f)} ${bold(`(L${l} C${c})`)}`,
+					);
+			})
+			.join("\n");
+	}
+
+	private log(
+		level: LogLevel,
+		message: unknown,
+		raw = false,
+	): string | undefined {
+		const msg = this.formatMessage(level, message);
+		if (raw) return msg;
+		console[this.logMethods[level]](msg);
+	}
+
+	public notif(m: unknown, raw = false) {
+		return this.log("notif", m, raw);
+	}
+	public alert(m: unknown, raw = false) {
+		return this.log("alert", m, raw);
+	}
+	public error(m: unknown, e?: Error, raw = false) {
+		return this.log("error", e ?? m, raw);
+	}
+	public debug(m: unknown, raw = false) {
+		return this.log("debug", m, raw);
+	}
+
+	public divider(text: string): void {
+		const line = dim("─".repeat(Math.max(0, (50 - text.length - 2) / 2)));
+		console.log(`\n${line} ${bold(text.trim())} ${line}`);
+	}
+}

package/src/lib/toOrdinal.ts

@@ -1,16 +1,14 @@
-const suffixes: Record<string, string> = {
-	one: "st",
-	two: "nd",
-	few: "rd",
-	other: "th",
-};
-
-/**
- * Converts a number to its ordinal value
- * 
- * @param n Number to convert
- * @returns string
- */
-export function toOrdinal(n: number): string {
-	return `${n}${suffixes[new Intl.PluralRules("en-US", { type: "ordinal" }).select(n)]}`;
-}
+const pr = new Intl.PluralRules("en-US", { type: "ordinal" });
+const suffixes: Record<Intl.LDMLPluralRule, string> = {
+	one: "st",
+	two: "nd",
+	few: "rd",
+	other: "th",
+	// Included for type safety
+	zero: "th",
+	many: "th",
+};
+
+export function toOrdinal(n: number): string {
+	return `${n}${suffixes[pr.select(n)]}`;
+}

package/src/lib/cooldownManager.ts

@@ -1,71 +0,0 @@
-export class CooldownManager {
-	public cds = new Map<string, Map<string, number>>();
-
-	set(uid: string, cmd: string, ttl: number): void {
-		if (ttl <= 0) return;
-
-		const expiry = Date.now() + ttl;
-		let userCmds = this.cds.get(uid);
-
-		if (!userCmds) {
-			userCmds = new Map();
-			this.cds.set(uid, userCmds);
-		}
-
-		userCmds.set(cmd, expiry);
-	}
-
-	has(uid: string, cmd: string): false | number {
-		const userCmds = this.cds.get(uid);
-		if (!userCmds) return false;
-
-		const expiry = userCmds.get(cmd);
-		if (!expiry) return false;
-
-		const remaining = expiry - Date.now();
-		if (remaining > 0) return remaining;
-
-		userCmds.delete(cmd);
-
-		if (userCmds.size === 0) this.cds.delete(uid);
-		return false;
-	}
-
-	del(uid: string, cmd: string): void {
-		const userCmds = this.cds.get(uid);
-		if (!userCmds) return;
-
-		userCmds.delete(cmd);
-
-		if (userCmds.size === 0) this.cds.delete(uid);
-	}
-
-	list(): Record<string, Record<string, number>> {
-		const result: ReturnType<CooldownManager["list"]> = {};
-		
-		for (const [uid, cmds] of this.cds) {
-			const cmdsObj: Record<string, number> = {};
-			for (const [cmd, expiry] of cmds) {
-				cmdsObj[cmd] = expiry;
-			}
-			result[uid] = cmdsObj;
-		}
-
-		return result;
-	}
-
-	clean(): void {
-		const now = Date.now();
-		for (const [uid, cmds] of this.cds) {
-			for (const [cmd, expiry] of Array.from(cmds)) {
-				if (expiry < now) cmds.delete(cmd);
-			}
-
-			if (cmds.size === 0) this.cds.delete(uid);
-		}
-	}
-
-	clear(): void {
-		void this.cds.clear();
-	}
-}

package/src/lib/logger.ts

@@ -1,125 +0,0 @@
-import { env } from "bun";
-import chalk from "chalk";
-
-type LogLevel = "notif" | "alert" | "error" | "debug";
-const { cyan, yellow, red, magenta, dim, gray, bold } = chalk;
-const formatter = new Intl.DateTimeFormat("en-AU", {
-	weekday: "short",
-	hour: "2-digit",
-	minute: "2-digit",
-	second: "2-digit",
-	hour12: false,
-});
-
-/**
- * Console logger
- */
-export class Logger {
-	private readonly colors: Record<LogLevel, typeof chalk> = {
-		notif: cyan,
-		alert: yellow,
-		error: red,
-		debug: magenta,
-	};
-
-	private readonly logMethods: Record<
-		LogLevel,
-		"log" | "warn" | "error" | "debug"
-	> = {
-		notif: "log",
-		alert: "warn",
-		error: "error",
-		debug: "debug",
-	};
-
-	private getTimestamp(): string {
-		const now = new Date();
-		const ms = now.getMilliseconds().toString().padStart(3, "0");
-		const base = formatter.format(now).replace(",", " @");
-		return `${base}.${ms}`;
-	}
-
-	private formatMessage(level: LogLevel, message: string | Error): string {
-		const timestamp = gray(`[${this.getTimestamp()}]`);
-		const levelLabel = bold(this.colors[level](level.toUpperCase().padEnd(5)));
-
-		const content =
-			message instanceof Error
-				? `${red(message.message)}\n${dim(this.sanitizeStack(message.stack || ""))}`
-				: message;
-
-		return `${timestamp} ${levelLabel} ${dim("»")} ${content}`;
-	}
-
-	private sanitizeStack(stack: string): string {
-		return stack
-			.split("\n")
-			.filter((line) => !line.includes("(native") && line.includes(":"))
-			.map((line, index) => {
-				if (index === 0) return false;
-				return (
-					line
-						.trim()
-						// TODO Need to do something with this
-						// .replace(/\\/g, "/")
-						// .replace(
-						// 	/(.*):(\d+):(\d+)/,
-						// 	(_, f, l, c) => `${dim(f)} ${bold(`(L${l} C${c})`)}`,
-						// )
-						.replace(/at\s+/, "  └─ ")
-				);
-			})
-			.filter(Boolean)
-			.join("\n");
-	}
-
-	private log(level: LogLevel, message: unknown, forceError?: boolean): void {
-		if (forceError) return void console.error(message);
-		void console[this.logMethods[level]](
-			this.formatMessage(level, message as string | Error),
-		);
-	}
-
-	/**
-	 * Pring a regular (info) message
-	 *
-	 * @param m Message to display
-	 */
-	public notif(m: unknown) {
-		this.log("notif", m);
-	}
-
-	/**
-	 * Print an alert (warning)
-	 *
-	 * @param m Message to display
-	 */
-	public alert(m: unknown) {
-		this.log("alert", m);
-	}
-
-	/**
-	 * Print an error
-	 *
-	 * @param m Message to display
-	 * @param e Error (optional)
-	 * @param f Force error - directly calls `console.error()`
-	 */
-	public error(m: unknown, e?: Error, f?: boolean) {
-		this.log("error", e ?? m, f);
-	}
-
-	/**
-	 * Print a debug message
-	 *
-	 * @param m Message to display
-	 */
-	public debug(m: unknown) {
-		this.log("debug", m);
-	}
-
-	public divider(text: string): void {
-		const line = dim("─".repeat(Math.max(0, (50 - text.length - 2) / 2)));
-		console.log(`\n${line} ${bold(text.trim())} ${line}`);
-	}
-}