feat(args): add more data to error context for core arguments

src/arguments/CoreCategoryChannel.ts

@@ -15,6 +15,10 @@ export class CoreArgument extends ExtendedArgument<'guildChannel', CategoryChann
 	public handle(channel: GuildChannel, context: ExtendedArgumentContext): ArgumentResult<CategoryChannel> {
 		return isCategoryChannel(channel)
 			? this.ok(channel)
-			: this.error({ parameter: context.parameter, message: 'The argument did not resolve to a category channel.', context });
+			: this.error({
+					parameter: context.parameter,
+					message: 'The argument did not resolve to a category channel.',
+					context: { ...context, channel }
+			  });
 	}
 }

src/arguments/CoreChannel.ts

@@ -9,6 +9,12 @@ export class CoreArgument extends Argument<Channel> {
 
 	public run(parameter: string, context: ArgumentContext): ArgumentResult<Channel> {
 		const channel = (context.message.guild ? context.message.guild.channels : this.context.client.channels).cache.get(parameter);
-		return channel ? this.ok(channel) : this.error({ parameter, message: 'The argument did not resolve to a channel.', context });
+		return channel
+			? this.ok(channel)
+			: this.error({
+					parameter,
+					message: 'The argument did not resolve to a channel.',
+					context: { ...context, channel }
+			  });
 	}
 }

src/arguments/CoreDMChannel.ts

@@ -12,6 +12,10 @@ export class CoreArgument extends ExtendedArgument<'channel', DMChannel> {
 	public handle(channel: Channel, context: ExtendedArgumentContext): ArgumentResult<DMChannel> {
 		return isDMChannel(channel)
 			? this.ok(channel)
-			: this.error({ parameter: context.parameter, message: 'The argument did not resolve to a DM channel.', context });
+			: this.error({
+					parameter: context.parameter,
+					message: 'The argument did not resolve to a DM channel.',
+					context: { ...context, channel }
+			  });
 	}
 }

src/arguments/CoreGuildChannel.ts

@@ -16,12 +16,18 @@ export class CoreArgument extends Argument<GuildChannel> {
 				parameter,
 				identifier: Identifiers.ArgumentGuildChannelMissingGuild,
 				message: 'The argument must be run in a guild.',
-				context
+				context: { ...context, guild }
 			});
 		}
 
 		const channel = this.resolveByID(parameter, guild) ?? this.resolveByQuery(parameter, guild);
-		return channel ? this.ok(channel) : this.error({ parameter, message: 'The argument did not resolve to a guild channel.', context });
+		return channel
+			? this.ok(channel)
+			: this.error({
+					parameter,
+					message: 'The argument did not resolve to a guild channel.',
+					context: { ...context, guild }
+			  });
 	}
 
 	private resolveByID(argument: string, guild: Guild): GuildChannel | null {

src/arguments/CoreMember.ts

@@ -16,12 +16,18 @@ export class CoreArgument extends Argument<GuildMember> {
 				parameter,
 				identifier: Identifiers.ArgumentMemberMissingGuild,
 				message: 'The argument must be run on a guild.',
-				context
+				context: { ...context, guild }
 			});
 		}
 
 		const member = (await this.resolveByID(parameter, guild)) ?? (await this.resolveByQuery(parameter, guild));
-		return member ? this.ok(member) : this.error({ parameter, message: 'The argument did not resolve to a member.', context });
+		return member
+			? this.ok(member)
+			: this.error({
+					parameter,
+					message: 'The argument did not resolve to a member.',
+					context: { ...context, guild }
+			  });
 	}
 
 	private async resolveByID(argument: string, guild: Guild): Promise<GuildMember | null> {

src/arguments/CoreMessage.ts

@@ -13,12 +13,18 @@ export class CoreArgument extends Argument<Message> {
 	}
 
 	public async run(parameter: string, context: MessageArgumentContext): AsyncArgumentResult<Message> {
-		const message = (await this.resolveByID(parameter, context)) ?? (await this.resolveByLink(parameter, context));
-		return message ? this.ok(message) : this.error({ parameter, message: 'The argument did not resolve to a message.', context });
+		const channel = context.channel ?? context.message.channel;
+		const message = (await this.resolveByID(parameter, channel)) ?? (await this.resolveByLink(parameter, context));
+		return message
+			? this.ok(message)
+			: this.error({
+					parameter,
+					message: 'The argument did not resolve to a message.',
+					context: { ...context, channel }
+			  });
 	}
 
-	private async resolveByID(argument: string, context: MessageArgumentContext): Promise<Message | null> {
-		const channel = context.channel ?? context.message.channel;
+	private async resolveByID(argument: string, channel: DMChannel | NewsChannel | TextChannel): Promise<Message | null> {
 		return SnowflakeRegex.test(argument) ? channel.messages.fetch(argument).catch(() => null) : null;
 	}
 

src/arguments/CoreNewsChannel.ts

@@ -15,6 +15,10 @@ export class CoreArgument extends ExtendedArgument<'guildChannel', NewsChannel>
 	public handle(channel: GuildChannel, context: ExtendedArgumentContext): ArgumentResult<NewsChannel> {
 		return isNewsChannel(channel)
 			? this.ok(channel)
-			: this.error({ parameter: context.parameter, message: 'The argument did not resolve to a news channel.', context });
+			: this.error({
+					parameter: context.parameter,
+					message: 'The argument did not resolve to a news channel.',
+					context: { ...context, channel }
+			  });
 	}
 }

src/arguments/CoreTextChannel.ts

@@ -15,6 +15,10 @@ export class CoreArgument extends ExtendedArgument<'guildChannel', TextChannel>
 	public handle(channel: GuildChannel, context: ExtendedArgumentContext): ArgumentResult<TextChannel> {
 		return isTextChannel(channel)
 			? this.ok(channel)
-			: this.error({ parameter: context.parameter, message: 'The argument did not resolve to a text channel.', context });
+			: this.error({
+					parameter: context.parameter,
+					message: 'The argument did not resolve to a text channel.',
+					context: { ...context, channel }
+			  });
 	}
 }

src/arguments/CoreVoiceChannel.ts

@@ -15,6 +15,10 @@ export class CoreArgument extends ExtendedArgument<'guildChannel', VoiceChannel>
 	public handle(channel: GuildChannel, context: ExtendedArgumentContext): ArgumentResult<VoiceChannel> {
 		return isVoiceChannel(channel)
 			? this.ok(channel)
-			: this.error({ parameter: context.parameter, message: 'The argument did not resolve to a voice channel.', context });
+			: this.error({
+					parameter: context.parameter,
+					message: 'The argument did not resolve to a voice channel.',
+					context: { ...context, channel }
+			  });
 	}
 }