bakit 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/{BakitClient-Cvt3Nhoi.d.ts → BakitClient-CgtDS6Hr.d.ts}

@@ -33,13 +33,13 @@ type Context<Cached extends boolean = boolean, InGuild extends boolean = boolean
 type CommandConstructor = new (...args: unknown[]) => object;
 declare function use(command: RootCommandEntry): (target: CommandConstructor) => void;
 declare function getRoot(constructor: CommandConstructor): RootCommandEntry | undefined;
-declare function CommandFactory(options: CreateOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
+declare function CommandFactory(options: CreateCommandOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
 declare const Command: typeof CommandFactory & {
     use: typeof use;
     getRoot: typeof getRoot;
 };
 
-declare enum HookExecutionState {
+declare enum CommandHookExecutionState {
     Main = "main",
     Pre = "pre",
     Post = "post",
@@ -47,7 +47,7 @@ declare enum HookExecutionState {
 }
 type CommandHookMethod = (ctx: Context, ...args: any[]) => Awaitable<void>;
 interface CommandHook {
-    state: HookExecutionState;
+    state: CommandHookExecutionState;
     method: CommandHookMethod;
     entry: CommandEntry;
 }
@@ -56,7 +56,7 @@ interface BaseCommandEntryOptions {
     description: string;
     nsfw?: boolean;
 }
-type CreateOptions<T extends BaseCommandEntryOptions> = SetOptional<T, "description"> | string;
+type CreateCommandOptions<T extends BaseCommandEntryOptions> = SetOptional<T, "description"> | string;
 declare const HOOKS_KEY: unique symbol;
 declare abstract class BaseCommandEntry {
     options: BaseCommandEntryOptions;
@@ -74,7 +74,7 @@ declare abstract class BaseCommandEntry {
 }
 declare abstract class BaseCommandGroupEntry extends BaseCommandEntry {
     children: Collection<string, CommandGroupEntry | SubcommandEntry>;
-    subcommand(options: CreateOptions<BaseCommandEntryOptions>): SubcommandEntry;
+    subcommand(options: CreateCommandOptions<BaseCommandEntryOptions>): SubcommandEntry;
 }
 declare class CommandGroupEntry extends BaseCommandGroupEntry {
     options: BaseCommandEntryOptions;
@@ -85,7 +85,7 @@ declare class CommandGroupEntry extends BaseCommandGroupEntry {
 declare class RootCommandEntry extends BaseCommandGroupEntry {
     options: BaseCommandEntryOptions;
     constructor(options: BaseCommandEntryOptions);
-    group(options: CreateOptions<BaseCommandEntryOptions>): CommandGroupEntry;
+    group(options: CreateCommandOptions<BaseCommandEntryOptions>): CommandGroupEntry;
 }
 declare class SubcommandEntry extends BaseCommandEntry {
     options: BaseCommandEntryOptions;
@@ -201,4 +201,4 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     private createHookRecord;
 }
 
-export { Arg as A, type BakitClientOptions as B, type CommandHookMethod as C, CommandSyntaxErrorType as D, type CommandSyntaxErrorOptions as E, CommandSyntaxError as F, type GetSyntaxErrorMessageFunction as G, HookExecutionState as H, type IntegerArgumentOptions as I, type MemberArgumentOptions as M, type NumberArgumentOptions as N, RootCommandEntry as R, type StringArgumentOptions as S, type UserArgumentOptions as U, BakitClient as a, ArgumentType as b, type BaseArgumentOptions as c, type ArgumentOptions as d, type CommandHook as e, type BaseCommandEntryOptions as f, type CreateOptions as g, HOOKS_KEY as h, BaseCommandEntry as i, BaseCommandGroupEntry as j, CommandGroupEntry as k, SubcommandEntry as l, type CommandEntry as m, type CommandConstructor as n, getRoot as o, CommandFactory as p, Command as q, CommandRegistry as r, type ChatInputContextSendOptions as s, type MessageContextSendOptions as t, use as u, type ContextSendOptions as v, BaseContext as w, ChatInputContext as x, MessageContext as y, type Context as z };
+export { Arg as A, BakitClient as B, CommandHookExecutionState as C, CommandSyntaxError as D, type GetSyntaxErrorMessageFunction as G, HOOKS_KEY as H, type IntegerArgumentOptions as I, type MemberArgumentOptions as M, type NumberArgumentOptions as N, RootCommandEntry as R, type StringArgumentOptions as S, type UserArgumentOptions as U, type BakitClientOptions as a, ArgumentType as b, type BaseArgumentOptions as c, type ArgumentOptions as d, type CommandHookMethod as e, type CommandHook as f, type BaseCommandEntryOptions as g, type CreateCommandOptions as h, BaseCommandEntry as i, BaseCommandGroupEntry as j, CommandGroupEntry as k, SubcommandEntry as l, type CommandEntry as m, type CommandConstructor as n, CommandFactory as o, Command as p, CommandRegistry as q, type ChatInputContextSendOptions as r, type MessageContextSendOptions as s, type ContextSendOptions as t, BaseContext as u, ChatInputContext as v, MessageContext as w, type Context as x, CommandSyntaxErrorType as y, type CommandSyntaxErrorOptions as z };

package/dist/command/index.d.ts

@@ -1,3 +1,3 @@
-export { A as Arg, d as ArgumentOptions, b as ArgumentType, c as BaseArgumentOptions, i as BaseCommandEntry, f as BaseCommandEntryOptions, j as BaseCommandGroupEntry, w as BaseContext, x as ChatInputContext, s as ChatInputContextSendOptions, q as Command, n as CommandConstructor, m as CommandEntry, p as CommandFactory, k as CommandGroupEntry, e as CommandHook, C as CommandHookMethod, r as CommandRegistry, z as Context, v as ContextSendOptions, g as CreateOptions, h as HOOKS_KEY, H as HookExecutionState, I as IntegerArgumentOptions, M as MemberArgumentOptions, y as MessageContext, t as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions, o as getRoot, u as use } from '../BakitClient-Cvt3Nhoi.js';
+export { A as Arg, d as ArgumentOptions, b as ArgumentType, 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, x as Context, t as ContextSendOptions, h as CreateCommandOptions, 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 'discord.js';
 import 'type-fest';

package/dist/command/index.js

@@ -106,13 +106,13 @@ var Arg = {
 
 // src/command/CommandEntry.ts
 import { Collection } from "discord.js";
-var HookExecutionState = /* @__PURE__ */ ((HookExecutionState2) => {
-  HookExecutionState2["Main"] = "main";
-  HookExecutionState2["Pre"] = "pre";
-  HookExecutionState2["Post"] = "post";
-  HookExecutionState2["Error"] = "error";
-  return HookExecutionState2;
-})(HookExecutionState || {});
+var CommandHookExecutionState = /* @__PURE__ */ ((CommandHookExecutionState2) => {
+  CommandHookExecutionState2["Main"] = "main";
+  CommandHookExecutionState2["Pre"] = "pre";
+  CommandHookExecutionState2["Post"] = "post";
+  CommandHookExecutionState2["Error"] = "error";
+  return CommandHookExecutionState2;
+})(CommandHookExecutionState || {});
 var HOOKS_KEY = Symbol("hooks");
 var BaseCommandEntry = class _BaseCommandEntry {
   constructor(options) {
@@ -467,12 +467,10 @@ export {
   Command,
   CommandFactory,
   CommandGroupEntry,
+  CommandHookExecutionState,
   CommandRegistry,
   HOOKS_KEY,
-  HookExecutionState,
   MessageContext,
   RootCommandEntry,
-  SubcommandEntry,
-  getRoot,
-  use
+  SubcommandEntry
 };

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-export { A as Arg, d as ArgumentOptions, b as ArgumentType, a as BakitClient, B as BakitClientOptions, c as BaseArgumentOptions, i as BaseCommandEntry, f as BaseCommandEntryOptions, j as BaseCommandGroupEntry, w as BaseContext, x as ChatInputContext, s as ChatInputContextSendOptions, q as Command, n as CommandConstructor, m as CommandEntry, p as CommandFactory, k as CommandGroupEntry, e as CommandHook, C as CommandHookMethod, r as CommandRegistry, F as CommandSyntaxError, E as CommandSyntaxErrorOptions, D as CommandSyntaxErrorType, z as Context, v as ContextSendOptions, g as CreateOptions, G as GetSyntaxErrorMessageFunction, h as HOOKS_KEY, H as HookExecutionState, I as IntegerArgumentOptions, M as MemberArgumentOptions, y as MessageContext, t as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions, o as getRoot, u as use } from './BakitClient-Cvt3Nhoi.js';
+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 { AsyncLocalStorage } from 'node:async_hooks';
-import 'discord.js';
-import 'type-fest';
+import { SetOptional } from 'type-fest';
+import { Awaitable, ClientEvents } from 'discord.js';
+import EventEmitter from 'node:events';
 
 declare function extractId(value: string): string | null;
 
@@ -15,4 +17,69 @@ declare class StateBox {
     static use<T extends object>(defaultValue?: unknown): (target: T, key: keyof T) => void;
 }
 
-export { StateBox, type States, extractId };
+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>;
+}
+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>> {
+    name: K;
+    once: boolean;
+    emitter?: EventEmitter;
+}
+declare class ListenerEntry<E extends EventsLike, K extends EventKey<E>> {
+    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 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 };

package/dist/index.js

@@ -122,13 +122,13 @@ var Arg = {
 };
 
 // src/command/CommandEntry.ts
-var HookExecutionState = /* @__PURE__ */ ((HookExecutionState2) => {
-  HookExecutionState2["Main"] = "main";
-  HookExecutionState2["Pre"] = "pre";
-  HookExecutionState2["Post"] = "post";
-  HookExecutionState2["Error"] = "error";
-  return HookExecutionState2;
-})(HookExecutionState || {});
+var CommandHookExecutionState = /* @__PURE__ */ ((CommandHookExecutionState2) => {
+  CommandHookExecutionState2["Main"] = "main";
+  CommandHookExecutionState2["Pre"] = "pre";
+  CommandHookExecutionState2["Post"] = "post";
+  CommandHookExecutionState2["Error"] = "error";
+  return CommandHookExecutionState2;
+})(CommandHookExecutionState || {});
 var HOOKS_KEY = Symbol("hooks");
 var BaseCommandEntry = class _BaseCommandEntry {
   constructor(options) {
@@ -564,13 +564,13 @@ var ArgumentResolver = class _ArgumentResolver {
     return this.options.message.client;
   }
   static create(message) {
-    const client = message.client;
-    const { enableMentionPrefix } = client.options;
+    const client2 = message.client;
+    const { enableMentionPrefix } = client2.options;
     const prefixes = [
       // Custom prefixes specified in options
-      ...client.options.prefixes ?? [],
+      ...client2.options.prefixes ?? [],
       // Use bot mention as prefix if enabled
-      ...enableMentionPrefix ? [client.user.toString()] : []
+      ...enableMentionPrefix ? [client2.user.toString()] : []
     ];
     const prefix = prefixes.find((p) => message.content.startsWith(p)) ?? null;
     if (!prefix) {
@@ -812,6 +812,140 @@ var StateBox = class _StateBox {
   }
 };
 
+// src/listener/ListenerEntry.ts
+var ListenerHookExecutionState = /* @__PURE__ */ ((ListenerHookExecutionState2) => {
+  ListenerHookExecutionState2["Main"] = "main";
+  ListenerHookExecutionState2["Pre"] = "pre";
+  ListenerHookExecutionState2["Post"] = "post";
+  ListenerHookExecutionState2["Error"] = "error";
+  return ListenerHookExecutionState2;
+})(ListenerHookExecutionState || {});
+var ListenerEntry = class _ListenerEntry {
+  constructor(options) {
+    this.options = options;
+  }
+  static hooksKey = Symbol("hooks");
+  static cache = /* @__PURE__ */ new WeakMap();
+  main = _ListenerEntry.createMainHookDecorator("main" /* Main */, this);
+  pre = _ListenerEntry.createMainHookDecorator("pre" /* Pre */, this);
+  post = _ListenerEntry.createMainHookDecorator("post" /* Post */, this);
+  error = _ListenerEntry.createErrorHookDecorator("error" /* Error */, this);
+  static getHooks(constructor, init = false) {
+    let hooks = this.cache.get(constructor) ?? Reflect.getMetadata(this.hooksKey, constructor);
+    if (!hooks) {
+      hooks = [];
+      if (init) {
+        Reflect.defineMetadata(this.hooksKey, hooks, constructor);
+        this.cache.set(constructor, hooks);
+      }
+    }
+    return init ? hooks : Object.freeze([...hooks]);
+  }
+  static createMainHookDecorator(state, entry) {
+    return (target, _key, descriptor) => {
+      this.addHook(target, state, descriptor.value, entry);
+    };
+  }
+  static createErrorHookDecorator(state, entry) {
+    return (target, _key, descriptor) => {
+      this.addHook(target, state, descriptor.value, entry);
+    };
+  }
+  static addHook(target, state, method, entry) {
+    const { constructor } = target;
+    const hooks = this.getHooks(constructor, true);
+    if (typeof method !== "function") {
+      throw new Error("CommandEntry decorator must be used with a class method.");
+    }
+    if (hooks.some((hook2) => hook2.state === state && hook2.entry === entry)) {
+      throw new Error(
+        `Hook "${state}" is already defined for entry "${String(entry.options.name)}".`
+      );
+    }
+    const hook = {
+      state,
+      entry,
+      method
+    };
+    hooks.push(hook);
+  }
+};
+
+// src/listener/Listener.ts
+function ListenerFactory(options) {
+  if (typeof options !== "object") {
+    options = {
+      name: options,
+      once: false
+    };
+  }
+  options.once = Boolean(options.once);
+  return new ListenerEntry(options);
+}
+var ENTRY_KEY = Symbol("entry");
+function use2(listener) {
+  return (target) => {
+    Reflect.defineMetadata(ENTRY_KEY, listener, target);
+  };
+}
+function getEntry(constructor) {
+  return Reflect.getMetadata(ENTRY_KEY, constructor);
+}
+var Listener = Object.assign(ListenerFactory, {
+  use: use2,
+  getEntry
+});
+
+// src/listener/ListenerRegistry.ts
+var client;
+var constructors = /* @__PURE__ */ new Set();
+var instances = /* @__PURE__ */ new WeakMap();
+function add(constructor) {
+  const entry = Listener.getEntry(constructor);
+  if (!entry) {
+    throw new Error(`No entry found for "${constructor.name}"`);
+  }
+  const { options } = entry;
+  if (!options.emitter) {
+    if (!client) {
+      throw new Error("Client is not ready.");
+    }
+    options.emitter = client;
+  }
+  constructors.add(constructor);
+  instances.set(constructor, new constructor());
+}
+function remove(constructor) {
+  const entry = Listener.getEntry(constructor);
+  if (!entry) {
+    return;
+  }
+  constructors.delete(constructor);
+  instances.delete(constructor);
+  const hook = ListenerEntry.getHooks(constructor).find((hook2) => hook2.entry === entry);
+  if (!hook) {
+    return;
+  }
+  const { name, emitter } = entry.options;
+  emitter?.removeListener(name, hook.method);
+}
+function removeAll() {
+  for (const constructor of constructors) {
+    remove(constructor);
+  }
+}
+function setClient(newClient) {
+  client = newClient;
+}
+var ListenerRegistry = {
+  constructors,
+  instances,
+  add,
+  setClient,
+  remove,
+  removeAll
+};
+
 // src/BakitClient.ts
 var BakitClient = class _BakitClient extends Client {
   constructor(options) {
@@ -819,9 +953,10 @@ var BakitClient = class _BakitClient extends Client {
       options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
     }
     super(options);
+    ListenerRegistry.setClient(this);
     this.once(
       Events.ClientReady,
-      (client) => void this.registerApplicationCommands(client)
+      (client2) => void this.registerApplicationCommands(client2)
     );
     this.on(Events.InteractionCreate, (interaction) => void this.handleInteraction(interaction));
     this.on(Events.MessageCreate, (message) => void this.handleMessage(message));
@@ -841,9 +976,9 @@ var BakitClient = class _BakitClient extends Client {
       content
     };
   };
-  async registerApplicationCommands(client) {
+  async registerApplicationCommands(client2) {
     const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
-    await client.application.commands.set(commands);
+    await client2.application.commands.set(commands);
   }
   async handleMessage(message) {
     if (message.author.bot) {
@@ -999,7 +1134,7 @@ var BakitClient = class _BakitClient extends Client {
     return { root, group, subcommand: sub };
   }
   createHookRecord(hooks) {
-    return Object.values(HookExecutionState).reduce(
+    return Object.values(CommandHookExecutionState).reduce(
       (acc, state) => {
         acc[state] = hooks.find((h) => h.state === state);
         return acc;
@@ -1019,16 +1154,19 @@ export {
   Command,
   CommandFactory,
   CommandGroupEntry,
+  CommandHookExecutionState,
   CommandRegistry,
   CommandSyntaxError,
   CommandSyntaxErrorType,
   HOOKS_KEY,
-  HookExecutionState,
+  Listener,
+  ListenerEntry,
+  ListenerFactory,
+  ListenerHookExecutionState,
+  ListenerRegistry,
   MessageContext,
   RootCommandEntry,
   StateBox,
   SubcommandEntry,
-  extractId,
-  getRoot,
-  use
+  extractId
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "1.0.0-beta.2",
+	"version": "1.0.0-beta.4",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {