bakit 1.0.0-beta.11 → 1.0.0-beta.12

package/dist/index.d.ts

@@ -1,9 +1,227 @@
-import { B as BaseEntry, C as ConstructorLike, a as BaseHook, b as BaseMainHookMethod, c as BaseErrorHookMethod, d as BakitClient } from './BakitClient-Dx4blRq3.js';
-export { A as Arg, h as ArgumentOptions, f as ArgumentType, e as BakitClientOptions, g as BaseArgumentOptions, m as BaseCommandEntry, k as BaseCommandEntryOptions, n as BaseCommandGroupEntry, x as BaseContext, y as ChatInputContext, u as ChatInputContextSendOptions, s as Command, q as CommandAPI, r as CommandFactory, o as CommandGroupEntry, j as CommandHook, t as CommandRegistry, J as CommandSyntaxError, H as CommandSyntaxErrorOptions, F as CommandSyntaxErrorType, D as Context, w as ContextSendOptions, l as CreateCommandOptions, E as ErrorCommandHookMethod, G as GetSyntaxErrorMessageFunction, I as IntegerArgumentOptions, i as MainCommandHookMethod, M as MemberArgumentOptions, z as MessageContext, v as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, p as SubcommandEntry, U as UserArgumentOptions } from './BakitClient-Dx4blRq3.js';
+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 { ClientEvents } from 'discord.js';
-import EventEmitter from 'node:events';
 import { SetOptional } from 'type-fest';
+import EventEmitter from 'node:events';
+
+type ConstructorLike = new (...args: unknown[]) => object;
+declare enum HookExecutionState {
+    Main = "MAIN",
+    Pre = "PRE",
+    Post = "POST",
+    Error = "ERROR"
+}
+type BaseMainHookMethod<Args extends unknown[]> = (...args: Args) => Awaitable<void>;
+type BaseErrorHookMethod<Args extends unknown[]> = (error: unknown, ...args: Args) => Awaitable<void>;
+interface BaseHook {
+    state: HookExecutionState;
+    method: BaseMainHookMethod<never> | BaseErrorHookMethod<never>;
+    entry: unknown;
+}
+declare class BaseEntry<Constructor extends ConstructorLike, Hook extends BaseHook, MainHookMethod extends BaseMainHookMethod<never>, ErrorHookMethod extends BaseErrorHookMethod<never>> {
+    protected target?: Constructor;
+    hooks: Record<HookExecutionState, Hook | undefined>;
+    main: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    pre: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    post: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    error: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    constructor();
+    setTarget(target: Constructor): void;
+    createMainHookDecorator(state: HookExecutionState): <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    createErrorHookDecorator(state: HookExecutionState): <T extends ErrorHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    protected addHook<T extends Hook["method"]>(state: HookExecutionState, target: object, descriptor: TypedPropertyDescriptor<T>): void;
+}
+
+type ChatInputContextSendOptions = string | InteractionReplyOptions;
+type MessageContextSendOptions = string | MessageCreateOptions;
+type ContextSendOptions = ChatInputContextSendOptions | MessageContextSendOptions;
+declare abstract class BaseContext<Cached extends boolean, InGuild extends boolean> {
+    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>;
+    constructor(source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>);
+    get client(): BakitClient<true>;
+    get channel(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.TextBasedChannel | null> | discord_js.If<InGuild, discord_js.GuildTextBasedChannel, discord_js.TextBasedChannel>;
+    get channelId(): string;
+    get guild(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.Guild, null, discord_js.Guild | null, discord_js.Guild | null> | discord_js.If<InGuild, discord_js.Guild, null>;
+    get guildId(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, string, string, string, string | null> | discord_js.If<InGuild, string, null>;
+    inGuild(): this is Context<Cached, true>;
+    inCachedGuild(): this is Context<true, true>;
+    get author(): User;
+    isChatInput(): this is ChatInputContext;
+    isMessage(): this is MessageContext;
+    abstract send(options: ContextSendOptions): Promise<Message<InGuild>>;
+}
+declare class ChatInputContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseContext<Cached, InGuild> {
+    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType>;
+    send(options: ContextSendOptions): Promise<Message<InGuild>>;
+}
+declare class MessageContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseContext<Cached, InGuild> {
+    source: Message<InGuild>;
+    send(options: string | MessageCreateOptions): Promise<Message<InGuild>>;
+}
+type Context<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
+
+type MainCommandHookMethod = BaseMainHookMethod<[context: Context, ...args: any[]]>;
+type ErrorCommandHookMethod = BaseErrorHookMethod<[context: Context, ...args: any[]]>;
+interface CommandHook extends BaseHook {
+    method: MainCommandHookMethod | ErrorCommandHookMethod;
+}
+interface BaseCommandEntryOptions {
+    name: string;
+    description: string;
+    nsfw?: boolean;
+}
+type CreateCommandOptions<T extends BaseCommandEntryOptions> = SetOptional<T, "description"> | string;
+declare class BaseCommandEntry extends BaseEntry<ConstructorLike, CommandHook, MainCommandHookMethod, ErrorCommandHookMethod> {
+    options: BaseCommandEntryOptions;
+    constructor(options: BaseCommandEntryOptions);
+}
+declare class BaseCommandGroupEntry extends BaseCommandEntry {
+    children: Collection<string, CommandGroupEntry | SubcommandEntry>;
+    subcommand(options: CreateCommandOptions<BaseCommandEntryOptions>): SubcommandEntry;
+}
+declare class RootCommandEntry extends BaseCommandGroupEntry {
+    group(options: CreateCommandOptions<BaseCommandEntryOptions>): CommandGroupEntry;
+}
+declare class CommandGroupEntry extends BaseCommandGroupEntry {
+    parent: RootCommandEntry;
+    children: Collection<string, SubcommandEntry>;
+    constructor(options: BaseCommandEntryOptions, parent: RootCommandEntry);
+}
+declare class SubcommandEntry extends BaseCommandEntry {
+    parent: BaseCommandGroupEntry;
+    constructor(options: BaseCommandEntryOptions, parent: BaseCommandGroupEntry);
+}
+
+declare enum ArgumentType {
+    String = "string",
+    Integer = "integer",
+    Number = "number",
+    User = "user",
+    Member = "member"
+}
+interface BaseArgumentOptions {
+    type: ArgumentType;
+    name: string;
+    description?: string;
+    required?: boolean;
+    tuple?: boolean;
+}
+interface StringArgumentOptions extends BaseArgumentOptions {
+    type: ArgumentType.String;
+    maxLength?: number;
+    minLength?: number;
+}
+interface IntegerArgumentOptions extends BaseArgumentOptions {
+    type: ArgumentType.Integer;
+    maxValue?: number;
+    minValue?: number;
+}
+interface NumberArgumentOptions extends BaseArgumentOptions {
+    type: ArgumentType.Number;
+    maxValue?: number;
+    minValue?: number;
+}
+interface UserArgumentOptions extends BaseArgumentOptions {
+    type: ArgumentType.User;
+}
+interface MemberArgumentOptions extends BaseArgumentOptions {
+    type: ArgumentType.Member;
+}
+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 const Arg: {
+    getMethodArguments: typeof getMethodArguments;
+    createArgument: typeof createArgument;
+    describeArgumentExpectation: typeof describeArgumentExpectation;
+    format: typeof format;
+    string: (options: string | Omit<StringArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    number: (options: string | Omit<NumberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    integer: (options: string | Omit<IntegerArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    user: (options: string | Omit<UserArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+};
+
+declare namespace CommandAPI {
+    function use(root: RootCommandEntry): (target: ConstructorLike) => void;
+    function getRoot(constructor: ConstructorLike): RootCommandEntry | undefined;
+}
+declare function CommandFactory(options: CreateCommandOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
+declare const Command: typeof CommandFactory & typeof CommandAPI;
+
+declare class CommandRegistry {
+    static constructors: Collection<string, ConstructorLike>;
+    static instances: Collection<string, object>;
+    /**
+     * Add a command to the registry.
+     * @param constructor The command class you want to add.
+     */
+    static add(constructor: ConstructorLike): void;
+    /**
+     * Load and add all commands which matched provided glob pattern to the registry.
+     * @param pattern glob pattern to load.
+     * @param parallel load all matched results in parallel, enabled by default.
+     * @returns All loaded command constructors.
+     */
+    static load(pattern: string, parallel?: boolean): Promise<ConstructorLike[]>;
+    /**
+     * Build a command into application command data.
+     * @param constructor The command class you want to build.
+     * @returns a REST JSON version of the application command data.
+     */
+    static buildSlashCommand(constructor: ConstructorLike): RESTPostAPIApplicationCommandsJSONBody;
+    private static getMainHookArguments;
+    private static buildSlashCommandSubcommands;
+    private static buildSlashCommandOptions;
+    private static attachSlashCommandOption;
+}
+
+declare enum CommandSyntaxErrorType {
+    MissingRequireArgument = "MISSING_REQUIRE_ARGUMENT",
+    InvalidArgument = "INVALID_ARGUMENT",
+    InvalidVariadicArgumentValue = "INVALID_VARIADIC_ARGUMENT_VALUE"
+}
+interface CommandSyntaxErrorOptions {
+    arg: ArgumentOptions;
+    type: CommandSyntaxErrorType;
+    received: unknown;
+}
+declare class CommandSyntaxError extends Error {
+    readonly arg: ArgumentOptions;
+    readonly type: CommandSyntaxErrorType;
+    readonly expected: unknown;
+    readonly received: unknown;
+    constructor(options: CommandSyntaxErrorOptions);
+    get name(): string;
+}
+
+type GetSyntaxErrorMessageFunction = (command: object, error: CommandSyntaxError, context: MessageContext, args: readonly ArgumentOptions[], prefix: string) => Awaitable<MessageCreateOptions | undefined>;
+interface BakitClientOptions extends ClientOptions {
+    prefixes?: string[];
+    enableMentionPrefix?: boolean;
+    getSyntaxErrorMessage?: GetSyntaxErrorMessageFunction | null;
+}
+declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready> {
+    options: Omit<BakitClientOptions, "intents"> & {
+        intents: IntentsBitField;
+    };
+    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;
+}
 
 declare function extractId(value: string): string | null;
 
@@ -93,4 +311,4 @@ declare module "discord.js" {
 	}
 }
 
-export { BakitClient, type ErrorListenerHookMethod, type EventsLike, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type MainListenerHookMethod, StateBox, type States, extractId };
+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 };