bakit 1.0.0-beta.3 → 1.0.0-beta.5

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

@@ -201,4 +201,4 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     private createHookRecord;
 }
 
-export { Arg as A, type BakitClientOptions as B, CommandHookExecutionState as C, CommandSyntaxErrorType as D, type CommandSyntaxErrorOptions as E, CommandSyntaxError as F, 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, BakitClient 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, 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, g 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, f as CommandHook, C as CommandHookExecutionState, e as CommandHookMethod, r as CommandRegistry, z as Context, v as ContextSendOptions, h as CreateCommandOptions, H as HOOKS_KEY, 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-BWs93qO-.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

@@ -472,7 +472,5 @@ export {
   HOOKS_KEY,
   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, g 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, f as CommandHook, C as CommandHookExecutionState, e as CommandHookMethod, r as CommandRegistry, F as CommandSyntaxError, E as CommandSyntaxErrorOptions, D as CommandSyntaxErrorType, z as Context, v as ContextSendOptions, h as CreateCommandOptions, G as GetSyntaxErrorMessageFunction, H as HOOKS_KEY, 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-BWs93qO-.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,63 @@ 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[]>;
+declare enum ListenerHookExecutionState {
+    Main = "main",
+    Pre = "pre",
+    Post = "post",
+    Error = "error"
+}
+type MainListenerHookMethod<Args extends unknown[]> = (...args: Args) => Awaitable<void>;
+type ErrorListenerHookMethod<Args extends unknown[]> = (error: unknown, ...args: Args) => Awaitable<void>;
+interface ListenerHook<E extends EventsLike, K extends keyof E> {
+    state: ListenerHookExecutionState;
+    method: MainListenerHookMethod<E[K] & unknown[]> | ErrorListenerHookMethod<E[K] & unknown[]>;
+    entry: ListenerEntry<E, K>;
+}
+interface ListenerEntryOptions<E extends EventsLike, K extends keyof E> {
+    name: K;
+    once: boolean;
+    emitter?: EventEmitter;
+}
+declare class ListenerEntry<E extends EventsLike, K extends keyof E> {
+    options: ListenerEntryOptions<E, K>;
+    static hooksKey: symbol;
+    private static cache;
+    main: <T extends MainListenerHookMethod<E[K] & unknown[]>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    pre: <T extends MainListenerHookMethod<E[K] & unknown[]>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    post: <T extends MainListenerHookMethod<E[K] & unknown[]>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    error: <T extends ErrorListenerHookMethod<E[K] & unknown[]>>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    constructor(options: ListenerEntryOptions<E, K>);
+    static getHooks<E extends EventsLike, K extends keyof E>(constructor: ListenerConstructor, init?: boolean): 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 keyof E> = SetOptional<ListenerEntryOptions<E, K>, "once"> | K;
+declare function ListenerFactory<E extends EventsLike = ClientEvents, K extends keyof E = keyof E>(options: CreateListenerOptions<E, K>): ListenerEntry<E, K>;
+declare const LISTENER_ENTRY_KEY: unique symbol;
+declare function use<E extends EventsLike = ClientEvents>(listener: ListenerEntry<E, keyof E>): (target: ListenerConstructor) => void;
+declare function getEntry<E extends EventsLike = ClientEvents, K extends keyof E = keyof E>(constructor: ListenerConstructor): ListenerEntry<E, K> | 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>;
+    executors: WeakMap<object, (...args: unknown[]) => Promise<void>>;
+    add: typeof add;
+    setClient: typeof setClient;
+    remove: typeof remove;
+    removeAll: typeof removeAll;
+};
+
+export { BakitClient, type CreateListenerOptions, type ErrorListenerHookMethod, type EventsLike, LISTENER_ENTRY_KEY, Listener, type ListenerConstructor, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerHookExecutionState, ListenerRegistry, type MainListenerHookMethod, StateBox, type States, extractId };

package/dist/index.js

@@ -813,26 +813,37 @@ var StateBox = class _StateBox {
 };
 
 // src/listener/ListenerEntry.ts
-var HOOKS_KEY2 = Symbol("hooks");
+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(HOOKS_KEY2, constructor);
+    const { cache: cache2 } = this;
+    let hooks = cache2.get(constructor) ?? Reflect.getMetadata(this.hooksKey, constructor);
     if (!hooks) {
       hooks = [];
       if (init) {
-        Reflect.defineMetadata(HOOKS_KEY2, hooks, constructor);
-        this.cache.set(constructor, hooks);
+        Reflect.defineMetadata(this.hooksKey, hooks, constructor);
+        this.cache.set(
+          constructor,
+          hooks
+        );
       }
     }
-    return init ? hooks : Object.freeze([...hooks]);
+    return init ? hooks : [...hooks];
   }
   static createMainHookDecorator(state, entry) {
     return (target, _key, descriptor) => {
@@ -866,23 +877,17 @@ var ListenerEntry = class _ListenerEntry {
 
 // 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);
+  const normalizedOptions = typeof options === "object" ? { once: false, ...options } : { name: options, once: false };
+  return new ListenerEntry(normalizedOptions);
 }
-var ENTRY_KEY = Symbol("entry");
+var LISTENER_ENTRY_KEY = Symbol("entry");
 function use2(listener) {
   return (target) => {
-    Reflect.defineMetadata(ENTRY_KEY, listener, target);
+    Reflect.defineMetadata(LISTENER_ENTRY_KEY, listener, target);
   };
 }
 function getEntry(constructor) {
-  return Reflect.getMetadata(ENTRY_KEY, constructor);
+  return Reflect.getMetadata(LISTENER_ENTRY_KEY, constructor);
 }
 var Listener = Object.assign(ListenerFactory, {
   use: use2,
@@ -893,6 +898,7 @@ var Listener = Object.assign(ListenerFactory, {
 var client;
 var constructors = /* @__PURE__ */ new Set();
 var instances = /* @__PURE__ */ new WeakMap();
+var executors = /* @__PURE__ */ new WeakMap();
 function add(constructor) {
   const entry = Listener.getEntry(constructor);
   if (!entry) {
@@ -905,8 +911,14 @@ function add(constructor) {
     }
     options.emitter = client;
   }
+  const instance = new constructor();
   constructors.add(constructor);
-  instances.set(constructor, new constructor());
+  instances.set(constructor, instance);
+  const executor = createExecutor(constructor, instance);
+  executors.set(instance, executor);
+  options.emitter[options.once ? "once" : "on"](options.name, (...args) => {
+    void executor(...args);
+  });
 }
 function remove(constructor) {
   const entry = Listener.getEntry(constructor);
@@ -914,13 +926,18 @@ function remove(constructor) {
     return;
   }
   constructors.delete(constructor);
+  const instance = instances.get(constructor);
+  if (!instance) {
+    return;
+  }
   instances.delete(constructor);
-  const hook = ListenerEntry.getHooks(constructor).find((hook2) => hook2.entry === entry);
-  if (!hook) {
+  const executor = executors.get(instance);
+  if (!executor) {
     return;
   }
   const { name, emitter } = entry.options;
-  emitter?.removeListener(name, hook.method);
+  emitter?.removeListener(name, executor);
+  executors.delete(instance);
 }
 function removeAll() {
   for (const constructor of constructors) {
@@ -930,9 +947,53 @@ function removeAll() {
 function setClient(newClient) {
   client = newClient;
 }
+function createExecutor(constructor, instance) {
+  const entry = Listener.getEntry(constructor);
+  if (!entry) {
+    throw new Error("Missing listener entry");
+  }
+  const hooks = ListenerEntry.getHooks(constructor).filter((hook) => hook.entry === entry);
+  const hookGroup = makeHookGroup(hooks);
+  return async function(...args) {
+    if (!hookGroup.main) {
+      return;
+    }
+    try {
+      if (hookGroup.pre) {
+        const preMethod = hookGroup.pre.method;
+        await preMethod.call(instance, ...args);
+      }
+      await hookGroup.main.method.call(instance, ...args);
+      if (hookGroup.post) {
+        const postMethod = hookGroup.post.method;
+        await postMethod.call(instance, ...args);
+      }
+    } catch (error) {
+      if (hookGroup.error) {
+        const errorMethod = hookGroup.error.method;
+        await errorMethod.call(instance, error, ...args);
+      } else {
+        throw error;
+      }
+    }
+  };
+}
+function makeHookGroup(hooks) {
+  const hooksByType = {
+    ["pre" /* Pre */]: void 0,
+    ["main" /* Main */]: void 0,
+    ["post" /* Post */]: void 0,
+    ["error" /* Error */]: void 0
+  };
+  for (const hook of hooks) {
+    hooksByType[hook.state] = hook;
+  }
+  return hooksByType;
+}
 var ListenerRegistry = {
   constructors,
   instances,
+  executors,
   add,
   setClient,
   remove,
@@ -1152,11 +1213,15 @@ export {
   CommandSyntaxError,
   CommandSyntaxErrorType,
   HOOKS_KEY,
+  LISTENER_ENTRY_KEY,
+  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.3",
+	"version": "1.0.0-beta.5",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {