feat: expose and use namespaces for options, context, etc (#330)

sapphiredev · Nov 21, 2021 · 85e7588 · 85e7588
1 parent cb40369
commit 85e7588
Show file tree

Hide file tree

Showing 43 changed files with 172 additions and 157 deletions.
diff --git a/package.json b/package.json
@@ -29,7 +29,7 @@
 	"dependencies": {
 		"@sapphire/discord-utilities": "^2.2.3",
 		"@sapphire/discord.js-utilities": "^4.1.3",
-		"@sapphire/pieces": "^3.1.1",
+		"@sapphire/pieces": "^3.2.0",
 		"@sapphire/ratelimits": "^2.1.9",
 		"@sapphire/utilities": "^3.1.0",
 		"lexure": "^0.17.0",

diff --git a/src/arguments/CoreBoolean.ts b/src/arguments/CoreBoolean.ts
@@ -1,13 +1,13 @@
 import type { PieceContext } from '@sapphire/pieces';
 import { resolveBoolean } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<boolean> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'boolean' });
 	}
 
-	public run(parameter: string, context: { truths?: string[]; falses?: string[] } & ArgumentContext): ArgumentResult<boolean> {
+	public run(parameter: string, context: { truths?: string[]; falses?: 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({

diff --git a/src/arguments/CoreChannel.ts b/src/arguments/CoreChannel.ts
@@ -1,14 +1,14 @@
 import type { ChannelTypes } from '@sapphire/discord.js-utilities';
 import type { PieceContext } from '@sapphire/pieces';
 import { resolveChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<ChannelTypes> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'channel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<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({

diff --git a/src/arguments/CoreDMChannel.ts b/src/arguments/CoreDMChannel.ts
@@ -1,14 +1,14 @@
 import type { PieceContext } from '@sapphire/pieces';
 import type { DMChannel } from 'discord.js';
 import { resolveDMChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<DMChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'dmChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<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({

diff --git a/src/arguments/CoreDate.ts b/src/arguments/CoreDate.ts
@@ -1,20 +1,20 @@
 import type { PieceContext } from '@sapphire/pieces';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveDate } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<Date> {
 	private readonly messages = {
-		[Identifiers.ArgumentDateTooEarly]: ({ minimum }: ArgumentContext) => `The given date must be after ${new Date(minimum!).toISOString()}.`,
-		[Identifiers.ArgumentDateTooFar]: ({ maximum }: ArgumentContext) => `The given date must be before ${new Date(maximum!).toISOString()}.`,
+		[Identifiers.ArgumentDateTooEarly]: ({ minimum }: Argument.Context) => `The given date must be after ${new Date(minimum!).toISOString()}.`,
+		[Identifiers.ArgumentDateTooFar]: ({ maximum }: Argument.Context) => `The given date must be before ${new Date(maximum!).toISOString()}.`,
 		[Identifiers.ArgumentDateError]: () => 'The argument did not resolve to a date.'
 	} as const;
 
 	public constructor(context: PieceContext) {
 		super(context, { name: 'date' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<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({

diff --git a/src/arguments/CoreFloat.ts b/src/arguments/CoreFloat.ts
@@ -1,20 +1,20 @@
 import type { PieceContext } from '@sapphire/pieces';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveFloat } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<number> {
 	private readonly messages = {
-		[Identifiers.ArgumentFloatTooSmall]: ({ minimum }: ArgumentContext) => `The given number must be greater than ${minimum}.`,
-		[Identifiers.ArgumentFloatTooLarge]: ({ maximum }: ArgumentContext) => `The given number must be less than ${maximum}.`,
+		[Identifiers.ArgumentFloatTooSmall]: ({ minimum }: Argument.Context) => `The given number must be greater than ${minimum}.`,
+		[Identifiers.ArgumentFloatTooLarge]: ({ maximum }: Argument.Context) => `The given number must be less than ${maximum}.`,
 		[Identifiers.ArgumentFloatError]: () => 'The argument did not resolve to a valid decimal.'
 	} as const;
 
 	public constructor(context: PieceContext) {
 		super(context, { name: 'float' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<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({

diff --git a/src/arguments/CoreGuildCategoryChannel.ts b/src/arguments/CoreGuildCategoryChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { CategoryChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildCategoryChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<CategoryChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildCategoryChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<CategoryChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<CategoryChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildChannel.ts b/src/arguments/CoreGuildChannel.ts
@@ -2,14 +2,14 @@ import type { GuildBasedChannelTypes } from '@sapphire/discord.js-utilities';
 import type { PieceContext } from '@sapphire/pieces';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<GuildBasedChannelTypes> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<GuildBasedChannelTypes> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<GuildBasedChannelTypes> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildNewsChannel.ts b/src/arguments/CoreGuildNewsChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { NewsChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildNewsChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<NewsChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildNewsChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<NewsChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<NewsChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildNewsThreadChannel.ts b/src/arguments/CoreGuildNewsThreadChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { ThreadChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildNewsThreadChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<ThreadChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildNewsThreadChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<ThreadChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<ThreadChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildPrivateThreadChannel.ts b/src/arguments/CoreGuildPrivateThreadChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { ThreadChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildPrivateThreadChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<ThreadChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildPrivateThreadChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<ThreadChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<ThreadChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildPublicThreadChannel.ts b/src/arguments/CoreGuildPublicThreadChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { ThreadChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildPublicThreadChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<ThreadChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildPublicThreadChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<ThreadChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<ThreadChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildStageVoiceChannel.ts b/src/arguments/CoreGuildStageVoiceChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { StageChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildStageVoiceChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<StageChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildStageVoiceChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<StageChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<StageChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildTextChannel.ts b/src/arguments/CoreGuildTextChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { TextChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildTextChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<TextChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildTextChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<TextChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<TextChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildThreadChannel.ts b/src/arguments/CoreGuildThreadChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { ThreadChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildThreadChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<ThreadChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildThreadChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<ThreadChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<ThreadChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreGuildVoiceChannel.ts b/src/arguments/CoreGuildVoiceChannel.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { VoiceChannel } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveGuildVoiceChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<VoiceChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'guildVoiceChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<VoiceChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<VoiceChannel> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreHyperlink.ts b/src/arguments/CoreHyperlink.ts
@@ -1,14 +1,14 @@
 import type { PieceContext } from '@sapphire/pieces';
 import type { URL } from 'url';
 import { resolveHyperlink } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<URL> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'hyperlink', aliases: ['url'] });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<URL> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<URL> {
 		const resolved = resolveHyperlink(parameter);
 		if (resolved.success) return this.ok(resolved.value);
 		return this.error({

diff --git a/src/arguments/CoreInteger.ts b/src/arguments/CoreInteger.ts
@@ -1,20 +1,20 @@
 import type { PieceContext } from '@sapphire/pieces';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveInteger } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<number> {
 	private readonly messages = {
-		[Identifiers.ArgumentIntegerTooSmall]: ({ minimum }: ArgumentContext) => `The given number must be greater than ${minimum}.`,
-		[Identifiers.ArgumentIntegerTooLarge]: ({ maximum }: ArgumentContext) => `The given number must be less than ${maximum}.`,
+		[Identifiers.ArgumentIntegerTooSmall]: ({ minimum }: Argument.Context) => `The given number must be greater than ${minimum}.`,
+		[Identifiers.ArgumentIntegerTooLarge]: ({ maximum }: Argument.Context) => `The given number must be less than ${maximum}.`,
 		[Identifiers.ArgumentIntegerError]: () => 'The argument did not resolve to a valid number.'
 	} as const;
 
 	public constructor(context: PieceContext) {
 		super(context, { name: 'integer' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<number> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<number> {
 		const resolved = resolveInteger(parameter, { minimum: context.minimum, maximum: context.maximum });
 		if (resolved.success) return this.ok(resolved.value);
 		return this.error({

diff --git a/src/arguments/CoreMember.ts b/src/arguments/CoreMember.ts
@@ -2,14 +2,14 @@ import type { PieceContext } from '@sapphire/pieces';
 import type { GuildMember } from 'discord.js';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveMember } from '../lib/resolvers';
-import { Argument, ArgumentContext, AsyncArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<GuildMember> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'member' });
 	}
 
-	public async run(parameter: string, context: ArgumentContext): AsyncArgumentResult<GuildMember> {
+	public async run(parameter: string, context: Argument.Context): Argument.AsyncResult<GuildMember> {
 		const { guild } = context.message;
 		if (!guild) {
 			return this.error({

diff --git a/src/arguments/CoreMessage.ts b/src/arguments/CoreMessage.ts
@@ -1,14 +1,14 @@
 import type { PieceContext } from '@sapphire/pieces';
 import type { Message } from 'discord.js';
 import { resolveMessage } from '../lib/resolvers';
-import { Argument, ArgumentContext, AsyncArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<Message> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'message' });
 	}
 
-	public async run(parameter: string, context: { channel?: Message['channel'] } & ArgumentContext): AsyncArgumentResult<Message> {
+	public async run(parameter: string, context: { channel?: Message['channel'] } & Argument.Context): Argument.AsyncResult<Message> {
 		const channel = context.channel ?? context.message.channel;
 		const resolved = await resolveMessage(parameter, { message: context.message, channel: context.channel });
 		if (resolved.success) return this.ok(resolved.value);

diff --git a/src/arguments/CoreNumber.ts b/src/arguments/CoreNumber.ts
@@ -1,20 +1,20 @@
 import type { PieceContext } from '@sapphire/pieces';
 import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveNumber } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<number> {
 	private readonly messages = {
-		[Identifiers.ArgumentNumberTooSmall]: ({ minimum }: ArgumentContext) => `The given number must be greater than ${minimum}.`,
-		[Identifiers.ArgumentNumberTooLarge]: ({ maximum }: ArgumentContext) => `The given number must be less than ${maximum}.`,
+		[Identifiers.ArgumentNumberTooSmall]: ({ minimum }: Argument.Context) => `The given number must be greater than ${minimum}.`,
+		[Identifiers.ArgumentNumberTooLarge]: ({ maximum }: Argument.Context) => `The given number must be less than ${maximum}.`,
 		[Identifiers.ArgumentNumberError]: () => 'The argument did not resolve to a valid number.'
 	} as const;
 
 	public constructor(context: PieceContext) {
 		super(context, { name: 'number' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<number> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<number> {
 		const resolved = resolveNumber(parameter, { minimum: context.minimum, maximum: context.maximum });
 		if (resolved.success) return this.ok(resolved.value);
 		return this.error({

diff --git a/src/arguments/CorePartialDMChannel.ts b/src/arguments/CorePartialDMChannel.ts
@@ -1,14 +1,14 @@
 import type { PieceContext } from '@sapphire/pieces';
 import type { DMChannel, PartialDMChannel } from 'discord.js';
 import { resolvePartialDMChannel } from '../lib/resolvers';
-import { Argument, ArgumentContext, ArgumentResult } from '../lib/structures/Argument';
+import { Argument } from '../lib/structures/Argument';
 
 export class CoreArgument extends Argument<DMChannel | PartialDMChannel> {
 	public constructor(context: PieceContext) {
 		super(context, { name: 'partialDMChannel' });
 	}
 
-	public run(parameter: string, context: ArgumentContext): ArgumentResult<DMChannel | PartialDMChannel> {
+	public run(parameter: string, context: Argument.Context): Argument.Result<DMChannel | PartialDMChannel> {
 		const resolved = resolvePartialDMChannel(parameter, context.message);
 		if (resolved.success) return this.ok(resolved.value);
 		return this.error({