bakit 1.0.0-beta.4 → 1.0.0-beta.7

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { B as BakitClient } from './BakitClient-CgtDS6Hr.js';
-export { A as Arg, d as ArgumentOptions, b as ArgumentType, a as BakitClientOptions, c as BaseArgumentOptions, i as BaseCommandEntry, g as BaseCommandEntryOptions, j as BaseCommandGroupEntry, u as BaseContext, v as ChatInputContext, r as ChatInputContextSendOptions, p as Command, n as CommandConstructor, m as CommandEntry, o as CommandFactory, k as CommandGroupEntry, f as CommandHook, C as CommandHookExecutionState, e as CommandHookMethod, q as CommandRegistry, D as CommandSyntaxError, z as CommandSyntaxErrorOptions, y as CommandSyntaxErrorType, x as Context, t as ContextSendOptions, h as CreateCommandOptions, G as GetSyntaxErrorMessageFunction, H as HOOKS_KEY, I as IntegerArgumentOptions, M as MemberArgumentOptions, w as MessageContext, s as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions } from './BakitClient-CgtDS6Hr.js';
+import { B as BaseEntry, C as ConstructorLike, a as BaseHook, b as BaseMainHookMethod, c as BaseErrorHookMethod, d as BakitClient } from './BakitClient-CU9viQZL.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-CU9viQZL.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { SetOptional } from 'type-fest';
-import { Awaitable, ClientEvents } from 'discord.js';
+import { ClientEvents } from 'discord.js';
 import EventEmitter from 'node:events';
+import { SetOptional } from 'type-fest';
 
 declare function extractId(value: string): string | null;
 
@@ -18,68 +18,79 @@ declare class StateBox {
 }
 
 type EventsLike = Record<keyof unknown, unknown[]>;
-type EventKey<E extends EventsLike> = keyof E;
-declare enum ListenerHookExecutionState {
-    Main = "main",
-    Pre = "pre",
-    Post = "post",
-    Error = "error"
-}
-type MainListenerHookMethod<E extends EventsLike, K extends EventKey<E>> = (...args: E[K] & unknown[]) => Awaitable<void>;
-type ErrorListenerHookMethod<E extends EventsLike, K extends EventKey<E>> = (error: unknown, ...args: E[K] & unknown[]) => Awaitable<void>;
-interface MainListenerHook<E extends EventsLike, K extends EventKey<E>> {
-    state: ListenerHookExecutionState.Main | ListenerHookExecutionState.Post | ListenerHookExecutionState.Pre;
-    method: MainListenerHookMethod<E, K>;
-    entry: ListenerEntry<E, K>;
+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[]>;
 }
-interface ErrorListenerHook<E extends EventsLike, K extends EventKey<E>> {
-    state: ListenerHookExecutionState.Error;
-    method: ErrorListenerHookMethod<E, K>;
-    entry: ListenerEntry<E, K>;
-}
-type ListenerHook<E extends EventsLike, K extends EventKey<E>> = MainListenerHook<E, K> | ErrorListenerHook<E, K>;
-interface ListenerEntryOptions<E extends EventsLike, K extends EventKey<E>> {
+interface ListenerEntryOptions<E extends EventsLike, K extends keyof E> {
     name: K;
     once: boolean;
     emitter?: EventEmitter;
 }
-declare class ListenerEntry<E extends EventsLike, K extends EventKey<E>> {
+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>;
-    static hooksKey: symbol;
-    private static cache;
-    main: <T extends MainListenerHookMethod<E, K>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
-    pre: <T extends MainListenerHookMethod<E, K>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
-    post: <T extends MainListenerHookMethod<E, K>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
-    error: <T extends ErrorListenerHookMethod<E, K>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
     constructor(options: ListenerEntryOptions<E, K>);
-    static getHooks<E extends EventsLike, K extends EventKey<E>>(constructor: ListenerConstructor): readonly ListenerHook<E, K>[];
-    static getHooks<E extends EventsLike, K extends EventKey<E>>(constructor: ListenerConstructor, init: true): ListenerHook<E, K>[];
-    private static createMainHookDecorator;
-    private static createErrorHookDecorator;
-    private static addHook;
 }
 
-type ListenerConstructor = new (...args: unknown[]) => object;
-type CreateListenerOptions<E extends EventsLike, K extends EventKey<E>> = SetOptional<ListenerEntryOptions<E, K>, "once"> | K;
-declare function ListenerFactory<E extends EventsLike = ClientEvents, K extends EventKey<E> = EventKey<E>>(options: CreateListenerOptions<E, K>): ListenerEntry<E, K>;
-declare function use(listener: ListenerEntry<never, never>): (target: ListenerConstructor) => void;
-declare function getEntry(constructor: ListenerConstructor): ListenerEntry<never, never> | undefined;
-declare const Listener: typeof ListenerFactory & {
-    use: typeof use;
-    getEntry: typeof getEntry;
-};
+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 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;
+
+/**
+ * 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>>;
+    /**
+     * 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.
+     */
+    static add(constructor: ConstructorLike): void;
+    /**
+     * 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.
+     */
+    static remove(constructor: ConstructorLike): boolean;
+    /**
+     * Remove and unregister all listeners from the registry.
+     * @returns Amount of removed listeners.
+     */
+    static removeAll(): number;
+    /**
+     * 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.
+     */
+    protected static setClient(newClient: BakitClient): void;
+    private static createExecutor;
+    /**
+     * 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.
+     */
+    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 function add(constructor: ListenerConstructor): void;
-declare function remove(constructor: ListenerConstructor): void;
-declare function removeAll(): void;
-declare function setClient(newClient: BakitClient): void;
-declare const ListenerRegistry: {
-    constructors: Set<ListenerConstructor>;
-    instances: WeakMap<ListenerConstructor, object>;
-    add: typeof add;
-    setClient: typeof setClient;
-    remove: typeof remove;
-    removeAll: typeof removeAll;
-};
 
-export { BakitClient, type CreateListenerOptions, type ErrorListenerHook, type ErrorListenerHookMethod, type EventKey, type EventsLike, Listener, type ListenerConstructor, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerHookExecutionState, ListenerRegistry, type MainListenerHook, type MainListenerHookMethod, StateBox, type States, extractId };
+declare module "discord.js" {
+	interface Base {
+		client: BakitClient<true>;
+	}
+}
+
+export { BakitClient, type ErrorListenerHookMethod, type EventsLike, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type MainListenerHookMethod, StateBox, type States, extractId };