bakit 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/index.d.ts

@@ -18,52 +18,45 @@ 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>;
+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 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> {
     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;
+    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 EventKey<E>>(constructor: ListenerConstructor): readonly ListenerHook<E, K>[];
-    static getHooks<E extends EventsLike, K extends EventKey<E>>(constructor: ListenerConstructor, init: true): ListenerHook<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 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;
+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;
@@ -76,10 +69,11 @@ 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 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 };
+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

@@ -831,15 +831,19 @@ var ListenerEntry = class _ListenerEntry {
   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);
+    const { cache: cache2 } = this;
+    let hooks = cache2.get(constructor) ?? Reflect.getMetadata(this.hooksKey, constructor);
     if (!hooks) {
       hooks = [];
       if (init) {
         Reflect.defineMetadata(this.hooksKey, hooks, constructor);
-        this.cache.set(constructor, hooks);
+        this.cache.set(
+          constructor,
+          hooks
+        );
       }
     }
-    return init ? hooks : Object.freeze([...hooks]);
+    return init ? hooks : [...hooks];
   }
   static createMainHookDecorator(state, entry) {
     return (target, _key, descriptor) => {
@@ -873,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,
@@ -900,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) {
@@ -912,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);
@@ -921,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) {
@@ -937,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,
@@ -1159,6 +1213,7 @@ export {
   CommandSyntaxError,
   CommandSyntaxErrorType,
   HOOKS_KEY,
+  LISTENER_ENTRY_KEY,
   Listener,
   ListenerEntry,
   ListenerFactory,

package/package.json

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