chore(*): wip, always

src/lib/parsers/Args.ts

@@ -1,6 +1,6 @@
 import type { ChannelTypes, GuildBasedChannelTypes } from '@sapphire/discord.js-utilities';
 import { container } from '@sapphire/pieces';
-import { err, isErr, isOk, isSome, maybe, ok, type Err, type Maybe, type Ok, type Result } from '@sapphire/result';
+import type { Result } from '@sapphire/result';
 import type {
 	CategoryChannel,
 	DMChannel,

src/lib/resolvers/boolean.ts

@@ -1,4 +1,4 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 const baseTruths = ['1', 'true', '+', 't', 'yes', 'y'] as const;
@@ -9,8 +9,8 @@ export function resolveBoolean(
 	customs?: { truths?: readonly string[]; falses?: readonly string[] }
 ): Result<boolean, Identifiers.ArgumentBooleanError> {
 	const boolean = parameter.toLowerCase();
-	if ([...baseTruths, ...(customs?.truths ?? [])].includes(boolean)) return ok(true);
-	if ([...baseFalses, ...(customs?.falses ?? [])].includes(boolean)) return ok(false);
+	if ([...baseTruths, ...(customs?.truths ?? [])].includes(boolean)) return Result.ok(true);
+	if ([...baseFalses, ...(customs?.falses ?? [])].includes(boolean)) return Result.ok(false);
 
-	return err(Identifiers.ArgumentBooleanError);
+	return Result.err(Identifiers.ArgumentBooleanError);
 }

src/lib/resolvers/channel.ts

@@ -1,12 +1,12 @@
 import { ChannelMentionRegex, ChannelTypes } from '@sapphire/discord.js-utilities';
 import { container } from '@sapphire/pieces';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Message, Snowflake } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveChannel(parameter: string, message: Message): Result<ChannelTypes, Identifiers.ArgumentChannelError> {
 	const channelId = (ChannelMentionRegex.exec(parameter)?.[1] ?? parameter) as Snowflake;
 	const channel = (message.guild ? message.guild.channels : container.client.channels).cache.get(channelId);
-	if (channel) return ok(channel as ChannelTypes);
-	return err(Identifiers.ArgumentChannelError);
+	if (channel) return Result.ok(channel as ChannelTypes);
+	return Result.err(Identifiers.ArgumentChannelError);
 }

src/lib/resolvers/date.ts

@@ -1,4 +1,4 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveDate(
@@ -8,10 +8,10 @@ export function resolveDate(
 	const parsed = new Date(parameter);
 
 	const time = parsed.getTime();
-	if (Number.isNaN(time)) return err(Identifiers.ArgumentDateError);
+	if (Number.isNaN(time)) return Result.err(Identifiers.ArgumentDateError);
 
-	if (typeof options?.minimum === 'number' && time < options.minimum) return err(Identifiers.ArgumentDateTooEarly);
-	if (typeof options?.maximum === 'number' && time > options.maximum) return err(Identifiers.ArgumentDateTooFar);
+	if (typeof options?.minimum === 'number' && time < options.minimum) return Result.err(Identifiers.ArgumentDateTooEarly);
+	if (typeof options?.maximum === 'number' && time > options.maximum) return Result.err(Identifiers.ArgumentDateTooFar);
 
-	return ok(parsed);
+	return Result.ok(parsed);
 }

src/lib/resolvers/dmChannel.ts

@@ -1,5 +1,5 @@
 import { isDMChannel } from '@sapphire/discord.js-utilities';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { DMChannel, Message } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 import { resolveChannel } from './channel';
@@ -10,6 +10,6 @@ export function resolveDMChannel(
 ): Result<DMChannel, Identifiers.ArgumentChannelError | Identifiers.ArgumentDMChannelError> {
 	const result = resolveChannel(parameter, message);
 	if (!result.success) return result;
-	if (isDMChannel(result.value) && !result.value.partial) return ok(result.value);
-	return err(Identifiers.ArgumentDMChannelError);
+	if (isDMChannel(result.value) && !result.value.partial) return Result.ok(result.value);
+	return Result.err(Identifiers.ArgumentDMChannelError);
 }

src/lib/resolvers/emoji.ts

@@ -1,13 +1,13 @@
 import { EmojiRegex, TwemojiRegex } from '@sapphire/discord-utilities';
-import { Err, err, Ok, ok } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Util } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 
-export function resolveEmoji(parameter: string): Ok<EmojiObject> | Err<Identifiers> {
+export function resolveEmoji(parameter: string): Result<EmojiObject, Identifiers> {
 	const twemoji = TwemojiRegex.exec(parameter)?.[0] ?? null;
 
 	if (twemoji) {
-		return ok<EmojiObject>({
+		return Result.ok<EmojiObject>({
 			name: twemoji,
 			id: null
 		});
@@ -19,11 +19,11 @@ export function resolveEmoji(parameter: string): Ok<EmojiObject> | Err<Identifie
 		const resolved = Util.parseEmoji(parameter) as EmojiObject | null;
 
 		if (resolved) {
-			return ok(resolved);
+			return Result.ok(resolved);
 		}
 	}
 
-	return err(Identifiers.ArgumentEmojiError);
+	return Result.err(Identifiers.ArgumentEmojiError);
 }
 
 export interface EmojiObject {

src/lib/resolvers/enum.ts

@@ -1,21 +1,21 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveEnum(
 	parameter: string,
 	options?: { enum?: string[]; caseInsensitive?: boolean }
 ): Result<string, Identifiers.ArgumentEnumEmptyError | Identifiers.ArgumentEnumError> {
 	if (!options?.enum?.length) {
-		return err(Identifiers.ArgumentEnumEmptyError);
+		return Result.err(Identifiers.ArgumentEnumEmptyError);
 	}
 
 	if (!options.caseInsensitive && !options.enum.includes(parameter)) {
-		return err(Identifiers.ArgumentEnumError);
+		return Result.err(Identifiers.ArgumentEnumError);
 	}
 
 	if (options.caseInsensitive && !options.enum.some((v) => v.toLowerCase() === parameter.toLowerCase())) {
-		return err(Identifiers.ArgumentEnumError);
+		return Result.err(Identifiers.ArgumentEnumError);
 	}
 
-	return ok(parameter);
+	return Result.ok(parameter);
 }

src/lib/resolvers/float.ts

@@ -1,15 +1,15 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveFloat(
 	parameter: string,
 	options?: { minimum?: number; maximum?: number }
 ): Result<number, Identifiers.ArgumentFloatError | Identifiers.ArgumentFloatTooSmall | Identifiers.ArgumentFloatTooLarge> {
 	const parsed = Number(parameter);
-	if (Number.isNaN(parsed)) return err(Identifiers.ArgumentFloatError);
+	if (Number.isNaN(parsed)) return Result.err(Identifiers.ArgumentFloatError);
 
-	if (typeof options?.minimum === 'number' && parsed < options.minimum) return err(Identifiers.ArgumentFloatTooSmall);
-	if (typeof options?.maximum === 'number' && parsed > options.maximum) return err(Identifiers.ArgumentFloatTooLarge);
+	if (typeof options?.minimum === 'number' && parsed < options.minimum) return Result.err(Identifiers.ArgumentFloatTooSmall);
+	if (typeof options?.maximum === 'number' && parsed > options.maximum) return Result.err(Identifiers.ArgumentFloatTooLarge);
 
-	return ok(parsed);
+	return Result.ok(parsed);
 }

src/lib/resolvers/guildChannel.ts

@@ -1,13 +1,13 @@
 import { ChannelMentionRegex, SnowflakeRegex } from '@sapphire/discord-utilities';
 import type { GuildBasedChannelTypes } from '@sapphire/discord.js-utilities';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Guild, Snowflake } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveGuildChannel(parameter: string, guild: Guild): Result<GuildBasedChannelTypes, Identifiers.ArgumentGuildChannelError> {
 	const channel = resolveById(parameter, guild) ?? resolveByQuery(parameter, guild);
-	if (channel) return ok(channel);
-	return err(Identifiers.ArgumentGuildChannelError);
+	if (channel) return Result.ok(channel);
+	return Result.err(Identifiers.ArgumentGuildChannelError);
 }
 
 function resolveById(argument: string, guild: Guild): GuildBasedChannelTypes | null {

src/lib/resolvers/hyperlink.ts

@@ -1,8 +1,8 @@
-import { err, from, isOk, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { URL } from 'url';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveHyperlink(parameter: string): Result<URL, Identifiers.ArgumentHyperlinkError> {
-	const result = from(() => new URL(parameter));
-	return isOk(result) ? result : err(Identifiers.ArgumentHyperlinkError);
+	const result = Result.from(() => new URL(parameter));
+	return result.isOk() ? result : Result.err(Identifiers.ArgumentHyperlinkError);
 }

src/lib/resolvers/integer.ts

@@ -1,15 +1,15 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveInteger(
 	parameter: string,
 	options?: { minimum?: number; maximum?: number }
 ): Result<number, Identifiers.ArgumentIntegerError | Identifiers.ArgumentIntegerTooSmall | Identifiers.ArgumentIntegerTooLarge> {
 	const parsed = Number(parameter);
-	if (!Number.isInteger(parsed)) return err(Identifiers.ArgumentIntegerError);
+	if (!Number.isInteger(parsed)) return Result.err(Identifiers.ArgumentIntegerError);
 
-	if (typeof options?.minimum === 'number' && parsed < options.minimum) return err(Identifiers.ArgumentIntegerTooSmall);
-	if (typeof options?.maximum === 'number' && parsed > options.maximum) return err(Identifiers.ArgumentIntegerTooLarge);
+	if (typeof options?.minimum === 'number' && parsed < options.minimum) return Result.err(Identifiers.ArgumentIntegerTooSmall);
+	if (typeof options?.maximum === 'number' && parsed > options.maximum) return Result.err(Identifiers.ArgumentIntegerTooLarge);
 
-	return ok(parsed);
+	return Result.ok(parsed);
 }

src/lib/resolvers/member.ts

@@ -1,12 +1,12 @@
 import { SnowflakeRegex, UserOrMemberMentionRegex } from '@sapphire/discord-utilities';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Guild, GuildMember, Snowflake } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 
 export async function resolveMember(parameter: string, guild: Guild): Promise<Result<GuildMember, Identifiers.ArgumentMemberError>> {
 	const member = (await resolveById(parameter, guild)) ?? (await resolveByQuery(parameter, guild));
-	if (member) return ok(member);
-	return err(Identifiers.ArgumentMemberError);
+	if (member) return Result.ok(member);
+	return Result.err(Identifiers.ArgumentMemberError);
 }
 
 async function resolveById(argument: string, guild: Guild): Promise<GuildMember | null> {

src/lib/resolvers/message.ts

@@ -8,7 +8,7 @@ import {
 	TextBasedChannelTypes
 } from '@sapphire/discord.js-utilities';
 import { container } from '@sapphire/pieces';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Awaitable } from '@sapphire/utilities';
 import { Message, Permissions, Snowflake, User } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
@@ -39,8 +39,8 @@ export async function resolveMessage(parameter: string, options: MessageResolver
 		(await resolveById(parameter, options)) ??
 		(await resolveByLink(parameter, options.message)) ??
 		(await resolveByChannelAndMessage(parameter, options.message));
-	if (message) return ok(message);
-	return err(Identifiers.ArgumentMessageError);
+	if (message) return Result.ok(message);
+	return Result.err(Identifiers.ArgumentMessageError);
 }
 
 function resolveById(parameter: string, options: MessageResolverOptions): Awaitable<Message | null> {

src/lib/resolvers/number.ts

@@ -1,15 +1,15 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveNumber(
 	parameter: string,
 	options?: { minimum?: number; maximum?: number }
 ): Result<number, Identifiers.ArgumentNumberError | Identifiers.ArgumentNumberTooSmall | Identifiers.ArgumentNumberTooLarge> {
 	const parsed = Number(parameter);
-	if (Number.isNaN(parsed)) return err(Identifiers.ArgumentNumberError);
+	if (Number.isNaN(parsed)) return Result.err(Identifiers.ArgumentNumberError);
 
-	if (typeof options?.minimum === 'number' && parsed < options.minimum) return err(Identifiers.ArgumentNumberTooSmall);
-	if (typeof options?.maximum === 'number' && parsed > options.maximum) return err(Identifiers.ArgumentNumberTooLarge);
+	if (typeof options?.minimum === 'number' && parsed < options.minimum) return Result.err(Identifiers.ArgumentNumberTooSmall);
+	if (typeof options?.maximum === 'number' && parsed > options.maximum) return Result.err(Identifiers.ArgumentNumberTooLarge);
 
-	return ok(parsed);
+	return Result.ok(parsed);
 }

src/lib/resolvers/partialDMChannel.ts

@@ -1,5 +1,5 @@
 import { isDMChannel } from '@sapphire/discord.js-utilities';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { DMChannel, Message, PartialDMChannel } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 import { resolveChannel } from './channel';
@@ -9,7 +9,7 @@ export function resolvePartialDMChannel(
 	message: Message
 ): Result<DMChannel | PartialDMChannel, Identifiers.ArgumentChannelError | Identifiers.ArgumentDMChannelError> {
 	const result = resolveChannel(parameter, message);
-	if (!result.success) return result;
-	if (isDMChannel(result.value)) return ok(result.value);
-	return err(Identifiers.ArgumentDMChannelError);
+	if (!result.isOk()) return result;
+	if (isDMChannel(result.value)) return Result.ok(result.value);
+	return Result.err(Identifiers.ArgumentDMChannelError);
 }

src/lib/resolvers/role.ts

@@ -1,12 +1,12 @@
 import { RoleMentionRegex, SnowflakeRegex } from '@sapphire/discord-utilities';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Guild, Role, Snowflake } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 
 export async function resolveRole(parameter: string, guild: Guild): Promise<Result<Role, Identifiers.ArgumentRoleError>> {
 	const role = (await resolveById(parameter, guild)) ?? resolveByQuery(parameter, guild);
-	if (role) return ok(role);
-	return err(Identifiers.ArgumentRoleError);
+	if (role) return Result.ok(role);
+	return Result.err(Identifiers.ArgumentRoleError);
 }
 
 async function resolveById(argument: string, guild: Guild): Promise<Role | null> {

src/lib/resolvers/string.ts

@@ -1,17 +1,17 @@
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import { Identifiers } from '../errors/Identifiers';
 
 export function resolveString(
 	parameter: string,
 	options?: { minimum?: number; maximum?: number }
 ): Result<string, Identifiers.ArgumentStringTooShort | Identifiers.ArgumentStringTooLong> {
 	if (typeof options?.minimum === 'number' && parameter.length < options.minimum) {
-		return err(Identifiers.ArgumentStringTooShort);
+		return Result.err(Identifiers.ArgumentStringTooShort);
 	}
 
 	if (typeof options?.maximum === 'number' && parameter.length > options.maximum) {
-		return err(Identifiers.ArgumentStringTooLong);
+		return Result.err(Identifiers.ArgumentStringTooLong);
 	}
 
-	return ok(parameter);
+	return Result.ok(parameter);
 }

src/lib/resolvers/user.ts

@@ -1,12 +1,12 @@
 import { SnowflakeRegex, UserOrMemberMentionRegex } from '@sapphire/discord-utilities';
 import { container } from '@sapphire/pieces';
-import { err, ok, Result } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Snowflake, User } from 'discord.js';
 import { Identifiers } from '../errors/Identifiers';
 
 export async function resolveUser(parameter: string): Promise<Result<User, Identifiers.ArgumentUserError>> {
 	const userId = UserOrMemberMentionRegex.exec(parameter) ?? SnowflakeRegex.exec(parameter);
 	const user = userId ? await container.client.users.fetch(userId[1] as Snowflake).catch(() => null) : null;
-	if (user) return ok(user);
-	return err(Identifiers.ArgumentUserError);
+	if (user) return Result.ok(user);
+	return Result.err(Identifiers.ArgumentUserError);
 }

src/lib/structures/InteractionHandler.ts

@@ -1,5 +1,5 @@
 import { Piece, PieceContext, PieceJSON, PieceOptions } from '@sapphire/pieces';
-import { Maybe, none, None, some, UnwrapMaybeValue } from '@sapphire/result';
+import { Result } from '@sapphire/result';
 import type { Awaitable } from '@sapphire/utilities';
 import type { Interaction } from 'discord.js';
 
@@ -61,18 +61,18 @@ export abstract class InteractionHandler<O extends InteractionHandler.Options =
 	 * @returns A {@link Maybe} (or a {@link Promise Promised} {@link Maybe}) that indicates if this interaction should be
 	 * handled by this handler, and any extra data that should be passed to the {@link InteractionHandler.run run method}
 	 */
-	public parse(_interaction: Interaction): Awaitable<Maybe<unknown>> {
+	public parse(_interaction: Interaction): Awaitable<Result.Ok<unknown>> {
 		return this.some();
 	}
 
-	public some(): Maybe<never>;
-	public some<T>(data: T): Maybe<T>;
-	public some<T>(data?: T): Maybe<T | undefined> {
-		return some(data);
+	public some(): Result.Ok<never>;
+	public some<T>(data: T): Result.Ok<T>;
+	public some<T>(data?: T): Result.Ok<T | undefined> {
+		return Result.ok(data);
 	}
 
-	public none(): None {
-		return none();
+	public none(): Result.Err<unknown> {
+		return Result.err();
 	}
 
 	public toJSON(): InteractionHandlerJSON {