bakit 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as discord_js from 'discord.js';
-import { Awaitable, ChatInputCommandInteraction, CacheType, Message, InteractionReplyOptions, MessageCreateOptions, User, Collection, RESTPostAPIApplicationCommandsJSONBody, Client, ClientOptions, IntentsBitField, ClientEvents } from 'discord.js';
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { Awaitable, ChatInputCommandInteraction, CacheType, Message, InteractionReplyOptions, MessageCreateOptions, User, Collection, RESTPostAPIApplicationCommandsJSONBody, ClientOptions, Client, IntentsBitField, ClientEvents } from 'discord.js';
 import { SetOptional } from 'type-fest';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import EventEmitter from 'node:events';
 
 type ConstructorLike = new (...args: unknown[]) => object;
@@ -91,13 +91,15 @@ declare class SubcommandEntry extends BaseCommandEntry {
     parent: BaseCommandGroupEntry;
     constructor(options: BaseCommandEntryOptions, parent: BaseCommandGroupEntry);
 }
+type CommandEntry = RootCommandEntry | CommandGroupEntry | SubcommandEntry;
 
 declare enum ArgumentType {
     String = "string",
     Integer = "integer",
     Number = "number",
     User = "user",
-    Member = "member"
+    Member = "member",
+    Literal = "literal"
 }
 interface BaseArgumentOptions {
     type: ArgumentType;
@@ -127,13 +129,17 @@ interface UserArgumentOptions extends BaseArgumentOptions {
 interface MemberArgumentOptions extends BaseArgumentOptions {
     type: ArgumentType.Member;
 }
+interface LiteralArgumentOptions extends Omit<BaseArgumentOptions, "name"> {
+    type: ArgumentType.Literal;
+    value: string;
+}
 type ArgumentOptions = StringArgumentOptions | IntegerArgumentOptions | NumberArgumentOptions | UserArgumentOptions | MemberArgumentOptions;
 
 declare function getMethodArguments(method: CommandHook["method"]): readonly ArgumentOptions[];
 declare function getMethodArguments(method: CommandHook["method"], init: true): ArgumentOptions[];
 declare function createArgument<Options extends ArgumentOptions>(type: Options["type"]): (options: Omit<Options, "type"> | string) => (target: object, key: string | symbol, _index: number) => void;
-declare function describeArgumentExpectation(arg: ArgumentOptions): string;
-declare function format(arg: ArgumentOptions): string;
+declare function describeArgumentExpectation(arg: ArgumentOptions | LiteralArgumentOptions): string;
+declare function format(arg: ArgumentOptions | LiteralArgumentOptions): string;
 declare const Arg: {
     getMethodArguments: typeof getMethodArguments;
     createArgument: typeof createArgument;
@@ -146,6 +152,36 @@ declare const Arg: {
     member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
 };
 
+interface ArgumentResolverOptions {
+    message: Message;
+    values: string[];
+    prefix: string;
+}
+declare class ArgumentResolver {
+    private _values;
+    prefix: string;
+    message: Message;
+    private _parsedValues;
+    private _args;
+    constructor(_values: string[], prefix: string, message: Message);
+    get commandName(): string;
+    get values(): readonly string[];
+    get parsedValues(): readonly unknown[];
+    get args(): readonly (ArgumentOptions | LiteralArgumentOptions)[];
+    get client(): BakitClient<true>;
+    static initialize(message: Message): Promise<ArgumentResolver | undefined>;
+    resolve(entry: CommandEntry, at?: number): Promise<void>;
+    protected parseExact(args: ArgumentOptions[], values: string[]): Promise<unknown[]>;
+    protected parseFlexible(args: ArgumentOptions[], values: string[]): Promise<unknown[]>;
+    private matchValue;
+    private matchUserValue;
+    private matchMemberValue;
+    private matchIntegerValue;
+    private matchNumberValue;
+    private matchStringValue;
+    static resolveChatInputOption(interaction: ChatInputCommandInteraction, arg: ArgumentOptions): string | number | discord_js.GuildMember | discord_js.User | discord_js.APIInteractionDataResolvedGuildMember | null;
+}
+
 declare namespace CommandAPI {
     function use(root: RootCommandEntry): (target: ConstructorLike) => void;
     function getRoot(constructor: ConstructorLike): RootCommandEntry | undefined;
@@ -199,9 +235,31 @@ declare class CommandSyntaxError extends Error {
     get name(): string;
 }
 
-type GetSyntaxErrorMessageFunction = (command: object, error: CommandSyntaxError, context: MessageContext, args: readonly ArgumentOptions[], prefix: string) => Awaitable<MessageCreateOptions | undefined>;
+type GetSyntaxErrorMessageFunction = (command: object, error: CommandSyntaxError, context: MessageContext, resolver: ArgumentResolver) => Awaitable<MessageCreateOptions | undefined>;
+declare const defaultGetSyntaxErrorMessage: GetSyntaxErrorMessageFunction;
+
+declare class CommandDispatcher {
+    client: BakitClient;
+    constructor(client: BakitClient);
+    getPrefixes(message: Message): Promise<string[]>;
+    handleChatInput(interaction: ChatInputCommandInteraction): Promise<void>;
+    private getChatInputTriggerChain;
+    private resolveChatInputEntry;
+    handleMessage(message: Message): Promise<void>;
+    private resolveCommandEntryChain;
+    private executeChain;
+    private executeHooks;
+}
+
+declare class DispatcherManager {
+    client: BakitClient;
+    command: CommandDispatcher;
+    constructor(client: BakitClient);
+}
+
+type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
 interface BakitClientOptions extends ClientOptions {
-    prefixes?: string[];
+    prefixes?: (string | GetPrefixFunction)[];
     enableMentionPrefix?: boolean;
     getSyntaxErrorMessage?: GetSyntaxErrorMessageFunction | null;
 }
@@ -209,25 +267,16 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     options: Omit<BakitClientOptions, "intents"> & {
         intents: IntentsBitField;
     };
+    dispatchers: DispatcherManager;
     constructor(options: BakitClientOptions);
-    static getSyntaxErrorMessage: GetSyntaxErrorMessageFunction;
-    private registerApplicationCommands;
-    private handleMessage;
-    private handleInteraction;
-    private handleChatInputHooks;
-    private handleMessageHooks;
-    private handleChildMessageHooks;
-    private runMessageHooks;
-    private runChatInputHooks;
-    private runHooks;
-    private getChatInputTargetHooks;
+    isReady(): this is BakitClient<true>;
+    private initializeHandlers;
 }
 
 declare function extractId(value: string): string | null;
 
 type States = Record<string | symbol, unknown>;
 declare class StateBox {
-    private static readonly STATES_KEY;
     static storage: AsyncLocalStorage<States>;
     private static getState;
     static run<R>(fn: () => R, store?: {}): R;
@@ -298,16 +347,4 @@ declare abstract class ListenerRegistry {
     static load(pattern: string, parallel?: boolean): Promise<ConstructorLike[]>;
 }
 
-/**
- * This file is used to redeclare original client to the custom one
- * Most of the structure is from Base, but some might be not
- */
-
-
-declare module "discord.js" {
-	interface Base {
-		client: BakitClient<true>;
-	}
-}
-
-export { Arg, type ArgumentOptions, ArgumentType, BakitClient, type BakitClientOptions, type BaseArgumentOptions, BaseCommandEntry, type BaseCommandEntryOptions, BaseCommandGroupEntry, BaseContext, ChatInputContext, type ChatInputContextSendOptions, Command, CommandAPI, CommandFactory, CommandGroupEntry, type CommandHook, CommandRegistry, CommandSyntaxError, type CommandSyntaxErrorOptions, CommandSyntaxErrorType, type Context, type ContextSendOptions, type CreateCommandOptions, type ErrorCommandHookMethod, type ErrorListenerHookMethod, type EventsLike, type GetSyntaxErrorMessageFunction, type IntegerArgumentOptions, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type MainCommandHookMethod, type MainListenerHookMethod, type MemberArgumentOptions, MessageContext, type MessageContextSendOptions, type NumberArgumentOptions, RootCommandEntry, StateBox, type States, type StringArgumentOptions, SubcommandEntry, type UserArgumentOptions, extractId };
+export { Arg, type ArgumentOptions, ArgumentResolver, type ArgumentResolverOptions, ArgumentType, BakitClient, type BakitClientOptions, type BaseArgumentOptions, BaseCommandEntry, type BaseCommandEntryOptions, BaseCommandGroupEntry, BaseContext, ChatInputContext, type ChatInputContextSendOptions, Command, CommandAPI, type CommandEntry, CommandFactory, CommandGroupEntry, type CommandHook, CommandRegistry, CommandSyntaxError, type CommandSyntaxErrorOptions, CommandSyntaxErrorType, type Context, type ContextSendOptions, type CreateCommandOptions, type ErrorCommandHookMethod, type ErrorListenerHookMethod, type EventsLike, type GetPrefixFunction, type GetSyntaxErrorMessageFunction, type IntegerArgumentOptions, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type LiteralArgumentOptions, type MainCommandHookMethod, type MainListenerHookMethod, type MemberArgumentOptions, MessageContext, type MessageContextSendOptions, type NumberArgumentOptions, RootCommandEntry, StateBox, type States, type StringArgumentOptions, SubcommandEntry, type UserArgumentOptions, defaultGetSyntaxErrorMessage, extractId };