bakit 1.0.0-beta.9 → 2.0.0-alpha.2

package/README.md

@@ -0,0 +1,35 @@
+# About us
+
+Bakit is a framework that makes building Discord bots easier.
+It's built on top of [discord.js](https://discord.js.org) and helps you handle the core system for your bot.
+
+<div align="center">
+	<a href="https://npmjs.com/package/bakit"><img src="https://img.shields.io/npm/v/bakit?logo=npm" alt="npm" /></a>
+	<a href="LICENSE"><img src="https://img.shields.io/github/license/louiszn/bakit" alt="License" /></a>
+	<a href="https://discord.gg/pGnKbMfXke"><img src="https://img.shields.io/discord/1353321517437681724?logo=discord&logoColor=white" alt="Discord" /></a>
+</div>
+
+> [!CAUTION]
+> This package is currently being rewritten. Many features from beta v1 have not yet been migrated.
+> It is not production-ready, and use in production environments is strongly discouraged.
+
+## Why Bakit?
+
+- 🧩 **Unified Command System** - write once for both slash and prefix command.
+- 🚀 **Clean API interfaces** - well-structured commands and events.
+- ⚡ **Lightweight** - minimal overhead, only what you need.
+- ✨ **TypeScript + ESM first** - modern JavaScript tooling out of the box.
+
+## Documentation
+
+Official documentation is now at https://bakit.louiszn.xyz.
+
+# Contributing
+
+Contributions are always welcome! But before doing that, make sure you have already checked existing issues and pull requests before making a new one.
+
+# Support
+
+If you like Bakit and want to support its development, you can buy me a coffee:
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/louiszn)

package/dist/index.d.ts

@@ -1,96 +1,332 @@
-import { B as BaseEntry, C as ConstructorLike, a as BaseHook, b as BaseMainHookMethod, c as BaseErrorHookMethod, d as BakitClient } from './BakitClient-D9kRvFS3.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-D9kRvFS3.js';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { ClientEvents } from 'discord.js';
-import EventEmitter from 'node:events';
-import { SetOptional } from 'type-fest';
+import * as discord_js from 'discord.js';
+import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, ClientEvents, Events, Client } from 'discord.js';
+import z$1, { z } from 'zod';
+import { inspect } from 'node:util';
 
-declare function extractId(value: string): string | null;
+declare const ProjectConfigSchema: z.ZodObject<{
+    intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
+    clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
+    entryDir: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
+type ProjectConfig = z.output<typeof ProjectConfigSchema>;
+/**
+ * Define config object for your project. This is just a cleaner way to define config.
+ * @param config The partial version of project config.
+ * @returns The same config you provided earlier.
+ */
+declare function defineConfig(config: ProjectConfigInput): ProjectConfigInput;
+/**
+ * Load the config file and save them for later usage.
+ * @param cwd The location of the config file, uses root by default.
+ * @returns The complete config with default values from the validation.
+ */
+declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
+/**
+ * Get the loaded config of the project.
+ * @returns The project config.
+ */
+declare function getConfig(): ProjectConfig;
 
-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;
-    static wrap<R>(fn: () => R): () => R;
-    static use<T extends object>(defaultValue?: unknown): (target: T, key: keyof T) => void;
+declare class Context {
+    canceled: boolean;
+    cancel(): void;
 }
 
-type EventsLike = Record<keyof unknown, unknown[]>;
-type MainListenerHookMethod<Args extends unknown[]> = BaseMainHookMethod<Args>;
-type ErrorListenerHookMethod<Args extends unknown[]> = BaseErrorHookMethod<Args>;
-interface ListenerHook<E extends EventsLike, K extends keyof E> extends BaseHook {
-    method: MainListenerHookMethod<E[K] & unknown[]> | ErrorListenerHookMethod<E[K] & unknown[]>;
+type ChatInputContextSendOptions = string | InteractionReplyOptions;
+type MessageContextSendOptions = string | MessageCreateOptions;
+type ContextSendOptions = ChatInputContextSendOptions | MessageContextSendOptions;
+declare abstract class BaseCommandContext<Cached extends boolean, InGuild extends boolean> extends Context {
+    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>;
+    get member(): discord_js.GuildMember | discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildMember, discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember | null> | null;
+    inGuild(): this is CommandContext<Cached, true>;
+    inCachedGuild(): this is CommandContext<true, true>;
+    get user(): User;
+    isChatInput(): this is ChatInputContext;
+    isMessage(): this is MessageContext;
+    abstract send(options: ContextSendOptions): Promise<Message<InGuild>>;
 }
-interface ListenerEntryOptions<E extends EventsLike, K extends keyof E> {
-    name: K;
-    once: boolean;
-    emitter?: EventEmitter;
+declare class ChatInputContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<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 BaseCommandContext<Cached, InGuild> {
+    source: Message<InGuild>;
+    send(options: string | MessageCreateOptions): Promise<Message<InGuild>>;
+}
+type CommandContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
+
+declare enum HookState {
+    Pre = "PRE",
+    Main = "MAIN",
+    Post = "POST",
+    Error = "ERROR"
+}
+declare enum HookOrder {
+    First = 0,
+    Last = 1
 }
-declare class ListenerEntry<E extends EventsLike, K extends keyof E> extends BaseEntry<ConstructorLike, ListenerHook<E, K>, MainListenerHookMethod<E[K] & unknown[]>, ErrorListenerHookMethod<E[K] & unknown[]>> {
-    options: ListenerEntryOptions<E, K>;
-    constructor(options: ListenerEntryOptions<E, K>);
+type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
+type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
+declare class LifecycleManager<C extends Context, Args extends unknown[]> {
+    id: string;
+    private readonly hooks;
+    constructor(id: string);
+    getName(name: string): string;
+    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
+    main(callback: MainHookCallback<C, Args>): this;
+    pre(callback: MainHookCallback<C, Args>): this;
+    post(callback: MainHookCallback<C, Args>): this;
+    error(callback: ErrorHookCallback<C, Args>): this;
+    execute(context: C, ...args: Args): Promise<void>;
 }
 
-declare namespace ListenerAPI {
-    const ENTRY_KEY: unique symbol;
-    function use<E extends EventsLike, K extends keyof E>(entry: ListenerEntry<E, K>): (target: ConstructorLike) => void;
-    function getEntry<E extends EventsLike, K extends keyof E>(target: ConstructorLike): ListenerEntry<E, K> | undefined;
+declare enum ParamUserType {
+    Bot = "bot",
+    Normal = "normal",
+    Any = "any"
 }
-declare function ListenerFactory<E extends EventsLike = ClientEvents, K extends keyof E = keyof E>(options: SetOptional<ListenerEntryOptions<E, K>, "once"> | K): ListenerEntry<E, K>;
-declare const Listener: typeof ListenerFactory & typeof ListenerAPI;
+declare const BaseParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const StringParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const NumberParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxValue: z.ZodOptional<z.ZodNumber>;
+    minValue: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type BaseParamOptions = z.input<typeof BaseParamSchema>;
+type StringOptions = z.input<typeof StringParamSchema>;
+type NumberOptions = z.input<typeof NumberParamSchema>;
 
-/**
- * The global listener registry of Bakit.
- */
-declare abstract class ListenerRegistry {
-    private static client;
-    static constructors: Set<ConstructorLike>;
-    static instances: WeakMap<ConstructorLike, object>;
-    static executors: WeakMap<object, (...args: unknown[]) => Promise<void>>;
+declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
+    options: Options & {
+        required: Required;
+    };
     /**
-     * Add and register a listener to the registry.
-     * If `options.emitter` is not provided, the registry will use the base `client` by default.
-     * @param constructor The listener class you want to add.
+     * **Internal Phantom Type**
+     *
+     * Used strictly for TypeScript type inference to determine the runtime value
+     * of this parameter. This property does not exist at runtime.
+     *
+     * @internal
      */
-    static add(constructor: ConstructorLike): void;
+    readonly _type: Required extends true ? OutputType : OutputType | null;
+    constructor(options: Options);
+    protected setOption(key: keyof Options, value: any): this;
+    name(value: string): this;
+    description(value: string): this;
+    required<V extends boolean>(value: V): BaseParam<Options, OutputType, V>;
     /**
-     * Remove and unregister a listener from the registry.
-     * @param constructor The listener class you want to remove.
-     * @returns `boolean`, returns `true` if the listener is removed successfully.
+     * Helper to normalize string inputs into an options object.
      */
-    static remove(constructor: ConstructorLike): boolean;
+    protected static getOptions<Options>(options: Options | string): Options;
+}
+declare class StringParam<Required extends boolean = true> extends BaseParam<StringOptions, string, Required> {
+    constructor(options: string | StringOptions);
+    required<V extends boolean>(value: V): StringParam<V>;
     /**
-     * Remove and unregister all listeners from the registry.
-     * @returns Amount of removed listeners.
+     * Sets the minimum allowed length for this string.
+     * Pass `null` to remove this constraint.
      */
-    static removeAll(): number;
+    min(length: number | null): this;
     /**
-     * Set base client for the registry to fallback as default emitter. This should be used only by BakitClient and stay untouched.
-     * @param newClient base client to set for the registry.
+     * Sets the maximum allowed length for this string.
+     * Pass `null` to remove this constraint.
      */
-    protected static setClient(newClient: BakitClient): void;
-    private static createExecutor;
+    max(length: number | null): this;
+}
+declare class NumberParam<Required extends boolean = true> extends BaseParam<NumberOptions, number, Required> {
+    constructor(options: string | NumberOptions);
+    required<V extends boolean>(value: V): NumberParam<V>;
+    /**
+     * Sets the minimum allowed value for this number.
+     * Pass `null` to remove this constraint.
+     */
+    min(value: number | null): this;
     /**
-     * Load and add all listeners 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 listener constructors.
+     * Sets the maximum allowed value for this number.
+     * Pass `null` to remove this constraint.
      */
-    static load(pattern: string, parallel?: boolean): Promise<ConstructorLike[]>;
+    max(value: number | null): this;
 }
+type AnyParam<Required extends boolean = true> = BaseParam<any, any, Required>;
+/**
+ * Helper type to extract the runtime value of a Param instance.
+ *
+ * @example
+ * const p = new StringParam("name").required(false);
+ * type T = InferParamValue<typeof p>; // string | null
+ */
+type InferParamValue<P extends AnyParam<any>> = P["_type"];
+type InferParamTuple<T extends readonly BaseParam<any, any, any>[]> = {
+    [K in keyof T]: T[K] extends AnyParam<any> ? InferParamValue<T[K]> : never;
+};
 
+declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    params: z.ZodDefault<z.ZodArray<z.ZodCustom<BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>, BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    description: string;
+    name: string;
+    params: BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>[];
+}, {
+    name: string;
+    params: BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>[];
+    description?: string | undefined;
+}>>;
+type CommandOptionsInput = z.input<typeof CommandOptionsSchema>;
+type CommandOptions = z.output<typeof CommandOptionsSchema>;
 /**
- * This file is used to redeclare original client to the custom one
- * Most of the structure is from Base, but some might be not
+ * The command entry, used for registering command.
  */
+declare class Command<ParamsList extends readonly AnyParam<any>[] = []> extends LifecycleManager<CommandContext, [
+    ...args: InferParamTuple<ParamsList>
+]> {
+    options: CommandOptions;
+    constructor(options: (Omit<CommandOptionsInput, "params"> & {
+        params?: ParamsList;
+    }) | string);
+}
+/**
+ * Define command entry, usually for modules.
+ * @param options The command options.
+ * @returns The entry of the command to deploy or register hooks.
+ * @example
+ * ```ts
+ * import { defineCommand } from "bakit";
+ *
+ * const command = defineCommand({
+ * 	name: "ping",
+ * 	description: "Displays bot's latency.",
+ * });
+ *
+ * command.main(async (context) => {
+ * 	await context.send(`Pong! ${context.client.ws.ping}ms!`);
+ * });
+ *
+ * export default command;
+ * ```
+ */
+declare function defineCommand<const ParamsList extends readonly AnyParam<any>[] = []>(options: (Omit<CommandOptionsInput, "params"> & {
+    params?: ParamsList;
+}) | string): Command<ParamsList>;
+
+declare class BaseClientManager {
+    client: BakitClient;
+    constructor(client: BakitClient);
+}
+
+declare class CommandManager extends BaseClientManager {
+    commands: Collection<string, Command<[]>>;
+    loadModules(): Promise<Command[]>;
+    add(command: Command): void;
+    remove(target: string | Command): Command | undefined;
+    get(name: string): Command<[]> | undefined;
+}
+
+declare const ListenerOptionsSchema: z$1.ZodObject<{
+    name: z$1.ZodEnum<typeof Events>;
+    once: z$1.ZodDefault<z$1.ZodBoolean>;
+}, z$1.z.core.$strip>;
+type ListenerOptions<K extends EventKey = EventKey> = Omit<z$1.input<typeof ListenerOptionsSchema>, "name"> & {
+    name: K;
+};
+type EventKey = keyof ClientEvents;
+declare class Listener<K extends EventKey = EventKey> extends LifecycleManager<Context, [...args: ClientEvents[K]]> {
+    options: ListenerOptions<K>;
+    constructor(options: K | ListenerOptions<K>);
+}
+declare function defineListener<const K extends EventKey = EventKey>(options: K | ListenerOptions<K>): Listener<K>;
 
+declare class ListenerManager extends BaseClientManager {
+    listeners: Listener[];
+    private executors;
+    loadModules(): Promise<Listener[]>;
+    add(listener: Listener): void;
+    remove(target: string | Listener): Listener[];
+}
 
-declare module "discord.js" {
-	interface Base {
-		client: BakitClient<true>;
-	}
+type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
+interface BakitClientEvents extends ClientEvents {
+    ready: [BakitClient<true>];
+    clientReady: [BakitClient<true>];
 }
+declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready> {
+    managers: {
+        commands: CommandManager;
+        listeners: ListenerManager;
+    };
+    constructor(options: ClientOptions);
+    start(token?: string): Promise<string>;
+    /**
+     * Check if the client is connected to gateway successfully and finished initialization.
+     */
+    isReady(): this is BakitClient<true>;
+    on<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    once<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    off<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    removeAllListeners(event?: keyof BakitClientEvents): this;
+    removeListener<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    emit<K extends keyof BakitClientEvents>(event: K, ...args: BakitClientEvents[K]): boolean;
+    /**
+     * Override BakitClient output when using logger for security concern.
+     * @returns `BakitClient {}`
+     */
+    [inspect.custom](): string;
+}
+
+declare const Params: {
+    readonly string: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+    }) => StringParam<Required>;
+    readonly number: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        maxValue?: number | undefined;
+        minValue?: number | undefined;
+    }) => NumberParam<Required>;
+};
 
-export { BakitClient, type ErrorListenerHookMethod, type EventsLike, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type MainListenerHookMethod, StateBox, type States, extractId };
+export { type AnyParam, BakitClient, type BakitClientEvents, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, type ContextSendOptions, type GetPrefixFunction, type InferParamTuple, type InferParamValue, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig };