refactor(*)!: absorb changes from result@2.0.0

package.json

@@ -31,13 +31,13 @@
 		"@discordjs/builders": "^0.16.0",
 		"@sapphire/discord-utilities": "^2.11.5",
 		"@sapphire/discord.js-utilities": "^4.11.3",
+		"@sapphire/lexure": "^1.0.1",
 		"@sapphire/pieces": "^3.3.5",
 		"@sapphire/ratelimits": "^2.4.4",
-		"@sapphire/result": "^1.1.1",
+		"@sapphire/result": "^2.2.0",
 		"@sapphire/stopwatch": "^1.4.1",
 		"@sapphire/utilities": "^3.8.0",
 		"@types/object-hash": "^2.2.1",
-		"lexure": "^0.17.0",
 		"object-hash": "^3.0.0",
 		"tslib": "^2.4.0"
 	},
@@ -53,11 +53,11 @@
 		"@types/jest": "^28.1.6",
 		"@types/node": "^18.6.3",
 		"@types/ws": "^8.5.3",
-		"@typescript-eslint/eslint-plugin": "^5.31.0",
-		"@typescript-eslint/parser": "^5.31.0",
+		"@typescript-eslint/eslint-plugin": "^5.32.0",
+		"@typescript-eslint/parser": "^5.32.0",
 		"cz-conventional-changelog": "^3.3.0",
 		"discord.js": "^13.9.2",
-		"eslint": "^8.20.0",
+		"eslint": "^8.21.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-prettier": "^4.2.1",
 		"gen-esm-wrapper": "^1.1.3",
@@ -70,7 +70,7 @@
 		"rollup": "^2.77.2",
 		"rollup-plugin-version-injector": "^1.3.3",
 		"ts-jest": "^28.0.7",
-		"typedoc": "^0.23.9",
+		"typedoc": "^0.23.10",
 		"typedoc-plugin-djs-links": "^1.2.0",
 		"typedoc-plugin-mdn-links": "^2.0.0",
 		"typescript": "^4.7.4"

src/arguments/CoreBoolean.ts

@@ -9,12 +9,13 @@ export class CoreArgument extends Argument<boolean> {
 
 	public run(parameter: string, context: { readonly truths?: string[]; falses?: readonly string[] } & Argument.Context): Argument.Result<boolean> {
 		const resolved = resolveBoolean(parameter, { truths: context.truths, falses: context.falses });
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The argument did not resolve to a boolean.',
-			context
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The argument did not resolve to a boolean.',
+				context
+			})
+		);
 	}
 }

src/arguments/CoreChannel.ts

@@ -10,12 +10,13 @@ export class CoreArgument extends Argument<ChannelTypes> {
 
 	public run(parameter: string, context: Argument.Context): Argument.Result<ChannelTypes> {
 		const resolved = resolveChannel(parameter, context.message);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The argument did not resolve to a channel.',
-			context
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The argument did not resolve to a channel.',
+				context
+			})
+		);
 	}
 }

src/arguments/CoreDMChannel.ts

@@ -10,12 +10,13 @@ export class CoreArgument extends Argument<DMChannel> {
 
 	public run(parameter: string, context: Argument.Context): Argument.Result<DMChannel> {
 		const resolved = resolveDMChannel(parameter, context.message);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The argument did not resolve to a DM channel.',
-			context
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The argument did not resolve to a DM channel.',
+				context
+			})
+		);
 	}
 }

src/arguments/CoreDate.ts

@@ -16,12 +16,13 @@ export class CoreArgument extends Argument<Date> {
 
 	public run(parameter: string, context: Argument.Context): Argument.Result<Date> {
 		const resolved = resolveDate(parameter, { minimum: context.minimum, maximum: context.maximum });
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: this.messages[resolved.error](context),
-			context
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: this.messages[identifier](context),
+				context
+			})
+		);
 	}
 }

src/arguments/CoreEmoji.ts

@@ -1,5 +1,4 @@
 import type { PieceContext } from '@sapphire/pieces';
-import { Identifiers } from '../lib/errors/Identifiers';
 import { EmojiObject, resolveEmoji } from '../lib/resolvers/emoji';
 import { Argument, ArgumentResult } from '../lib/structures/Argument';
 
@@ -8,14 +7,15 @@ export class CoreArgument extends Argument<EmojiObject> {
 		super(context, { name: 'emoji' });
 	}
 
-	public run(parameter: string): ArgumentResult<EmojiObject> {
+	public run(parameter: string, context: Argument.Context): ArgumentResult<EmojiObject> {
 		const resolved = resolveEmoji(parameter);
-		return resolved.success
-			? this.ok(resolved.value)
-			: this.error({
-					parameter,
-					identifier: Identifiers.ArgumentEmojiError,
-					message: 'The argument did not resolve to an emoji.'
-			  });
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The argument did not resolve to an emoji.',
+				context
+			})
+		);
 	}
 }

src/arguments/CoreEnum.ts

@@ -12,12 +12,13 @@ export class CoreArgument extends Argument<string> {
 		context: { readonly enum?: string[]; readonly caseInsensitive?: boolean } & Argument.Context
 	): Argument.Result<string> {
 		const resolved = resolveEnum(parameter, { enum: context.enum, caseInsensitive: context.caseInsensitive });
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: `The argument must have one of the following values: ${context.enum?.join(', ')}`,
-			context
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: `The argument must have one of the following values: ${context.enum?.join(', ')}`,
+				context
+			})
+		);
 	}
 }

src/arguments/CoreFloat.ts

@@ -16,12 +16,13 @@ export class CoreArgument extends Argument<number> {
 
 	public run(parameter: string, context: Argument.Context): Argument.Result<number> {
 		const resolved = resolveFloat(parameter, { minimum: context.minimum, maximum: context.maximum });
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: this.messages[resolved.error](context),
-			context
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: this.messages[identifier](context),
+				context
+			})
+		);
 	}
 }

src/arguments/CoreGuildCategoryChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<CategoryChannel> {
 		}
 
 		const resolved = resolveGuildCategoryChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The argument did not resolve to a valid server category channel.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The argument did not resolve to a valid server category channel.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<GuildBasedChannelTypes> {
 		}
 
 		const resolved = resolveGuildChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The argument did not resolve to a valid server channel.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The argument did not resolve to a valid server channel.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildNewsChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<NewsChannel> {
 		}
 
 		const resolved = resolveGuildNewsChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid announcements channel.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid announcements channel.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildNewsThreadChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<ThreadChannel> {
 		}
 
 		const resolved = resolveGuildNewsThreadChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid announcements thread.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid announcements thread.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildPrivateThreadChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<ThreadChannel> {
 		}
 
 		const resolved = resolveGuildPrivateThreadChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid private thread.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid private thread.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildPublicThreadChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<ThreadChannel> {
 		}
 
 		const resolved = resolveGuildPublicThreadChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid public thread.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid public thread.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildStageVoiceChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<StageChannel> {
 		}
 
 		const resolved = resolveGuildStageVoiceChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid stage voice channel.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid stage voice channel.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildTextChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<TextChannel> {
 		}
 
 		const resolved = resolveGuildTextChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid text channel.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid text channel.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }

src/arguments/CoreGuildThreadChannel.ts

@@ -21,12 +21,13 @@ export class CoreArgument extends Argument<ThreadChannel> {
 		}
 
 		const resolved = resolveGuildThreadChannel(parameter, guild);
-		if (resolved.success) return this.ok(resolved.value);
-		return this.error({
-			parameter,
-			identifier: resolved.error,
-			message: 'The given argument did not resolve to a valid thread.',
-			context: { ...context, guild }
-		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter,
+				identifier,
+				message: 'The given argument did not resolve to a valid thread.',
+				context: { ...context, guild }
+			})
+		);
 	}
 }