bakit 1.0.0-beta.1 → 1.0.0-beta.2

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

@@ -31,11 +31,13 @@ declare class MessageContext<Cached extends boolean = boolean, InGuild extends b
 type Context<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
 
 type CommandConstructor = new (...args: unknown[]) => object;
-declare abstract class Command {
-    static create(options: CreateOptions<BaseCommandEntryOptions>): RootCommandEntry;
-    static use(command: RootCommandEntry): (target: CommandConstructor) => void;
-    static getRoot(constructor: CommandConstructor): RootCommandEntry | undefined;
-}
+declare function use(command: RootCommandEntry): (target: CommandConstructor) => void;
+declare function getRoot(constructor: CommandConstructor): RootCommandEntry | undefined;
+declare function CommandFactory(options: CreateOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
+declare const Command: typeof CommandFactory & {
+    use: typeof use;
+    getRoot: typeof getRoot;
+};
 
 declare enum HookExecutionState {
     Main = "main",
@@ -129,19 +131,22 @@ interface MemberArgumentOptions extends BaseArgumentOptions {
 }
 type ArgumentOptions = StringArgumentOptions | IntegerArgumentOptions | NumberArgumentOptions | UserArgumentOptions | MemberArgumentOptions;
 
-declare abstract class Arg {
-    private static cache;
-    static string: (options: string | Omit<StringArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static integer: (options: string | Omit<IntegerArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static number: (options: string | Omit<NumberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static user: (options: string | Omit<UserArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static getMethodArguments(method: CommandHook["method"]): readonly ArgumentOptions[];
-    static getMethodArguments(method: CommandHook["method"], init: true): ArgumentOptions[];
-    static format(arg: ArgumentOptions): string;
-    static describeArgumentExpectation(arg: ArgumentOptions): string;
-    protected static createArgument<Options extends ArgumentOptions>(type: Options["type"]): (options: Omit<Options, "type"> | string) => (target: object, key: string | symbol, _index: number) => void;
-}
+declare function getMethodArguments(method: CommandHook["method"]): readonly ArgumentOptions[];
+declare function getMethodArguments(method: CommandHook["method"], init: true): ArgumentOptions[];
+declare function createArgument<Options extends ArgumentOptions>(type: Options["type"]): (options: Omit<Options, "type"> | string) => (target: object, key: string | symbol, _index: number) => void;
+declare function describeArgumentExpectation(arg: ArgumentOptions): string;
+declare function format(arg: ArgumentOptions): string;
+declare const Arg: {
+    getMethodArguments: typeof getMethodArguments;
+    createArgument: typeof createArgument;
+    describeArgumentExpectation: typeof describeArgumentExpectation;
+    format: typeof format;
+    string: (options: string | Omit<StringArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    number: (options: string | Omit<NumberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    integer: (options: string | Omit<IntegerArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    user: (options: string | Omit<UserArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+};
 
 declare class CommandRegistry {
     static constructors: Collection<string, CommandConstructor>;
@@ -196,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, 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, Command as o, CommandRegistry as p, type ChatInputContextSendOptions as q, type MessageContextSendOptions as r, type ContextSendOptions as s, BaseContext as t, ChatInputContext as u, MessageContext as v, type Context as w, CommandSyntaxErrorType as x, type CommandSyntaxErrorOptions as y, CommandSyntaxError as z };
+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 };

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, t as BaseContext, u as ChatInputContext, q as ChatInputContextSendOptions, o as Command, n as CommandConstructor, m as CommandEntry, k as CommandGroupEntry, e as CommandHook, C as CommandHookMethod, p as CommandRegistry, w as Context, s as ContextSendOptions, g as CreateOptions, h as HOOKS_KEY, H as HookExecutionState, I as IntegerArgumentOptions, M as MemberArgumentOptions, v as MessageContext, r as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions } from '../BakitClient-BWxRFtSg.js';
+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';
 import 'discord.js';
 import 'type-fest';

package/dist/command/index.js

@@ -13,86 +13,95 @@ var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
 
 // src/command/argument/Arg.ts
 var ARGS_KEY = Symbol("args");
-var Arg = class _Arg {
-  static cache = /* @__PURE__ */ new WeakMap();
-  static string = _Arg.createArgument("string" /* String */);
-  static integer = _Arg.createArgument("integer" /* Integer */);
-  static number = _Arg.createArgument("number" /* Number */);
-  static user = _Arg.createArgument("user" /* User */);
-  static member = _Arg.createArgument("member" /* Member */);
-  static getMethodArguments(method, init = false) {
-    let args = this.cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
-    if (!args) {
-      args = [];
-      if (init) {
-        Reflect.defineMetadata(ARGS_KEY, args, method);
-        this.cache.set(method, args);
-      }
+var cache = /* @__PURE__ */ new WeakMap();
+function getMethodArguments(method, init = false) {
+  let args = cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
+  if (!args) {
+    args = [];
+    if (init) {
+      Reflect.defineMetadata(ARGS_KEY, args, method);
+      cache.set(method, args);
     }
-    return init ? args : Object.freeze([...args]);
   }
-  static format(arg) {
-    const { name, required, tuple } = arg;
-    const opening = required ? "<" : "[";
-    const closing = required ? ">" : "]";
-    const prefix = tuple ? "..." : "";
-    return `${opening}${prefix}${name}: ${this.describeArgumentExpectation(arg)}${closing}`;
-  }
-  static describeArgumentExpectation(arg) {
-    const parts = [arg.type];
-    switch (arg.type) {
-      case "string" /* String */: {
-        if (arg.minLength && !arg.maxLength) {
-          parts.push(`\u2265 ${String(arg.minLength)}`);
-        }
-        if (!arg.minLength && arg.maxLength) {
-          parts.push(`\u2264 ${String(arg.maxLength)}`);
-        }
-        if (arg.minLength && arg.maxLength) {
-          parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
-        }
-        break;
+  return init ? args : Object.freeze([...args]);
+}
+function createArgument(type) {
+  return function(options) {
+    const objOptions = typeof options === "string" ? { name: options } : options;
+    const fullOptions = { ...objOptions, type };
+    if (!fullOptions.description) {
+      fullOptions.description = fullOptions.name;
+    }
+    if (!("required" in fullOptions)) {
+      fullOptions.required = true;
+    }
+    return function(target, key, _index) {
+      const method = Object.getOwnPropertyDescriptor(target, key)?.value;
+      if (!method) {
+        throw new Error("No method found");
       }
-      case "number" /* Number */:
-      case "integer" /* Integer */: {
-        if (arg.minValue !== void 0 && arg.maxValue === void 0) {
-          parts.push(`\u2265 ${String(arg.minValue)}`);
-        }
-        if (arg.minValue === void 0 && arg.maxValue !== void 0) {
-          parts.push(`\u2264 ${String(arg.maxValue)}`);
-        }
-        if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
-          parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
-        }
-        break;
+      const args = getMethodArguments(method, true);
+      args.unshift(fullOptions);
+    };
+  };
+}
+var string = createArgument("string" /* String */);
+var integer = createArgument("integer" /* Integer */);
+var number = createArgument("number" /* Number */);
+var user = createArgument("user" /* User */);
+var member = createArgument("member" /* Member */);
+function describeArgumentExpectation(arg) {
+  const parts = [arg.type];
+  switch (arg.type) {
+    case "string" /* String */: {
+      if (arg.minLength && !arg.maxLength) {
+        parts.push(`\u2265 ${String(arg.minLength)}`);
       }
-      case "user" /* User */:
-      case "member" /* Member */: {
-        break;
+      if (!arg.minLength && arg.maxLength) {
+        parts.push(`\u2264 ${String(arg.maxLength)}`);
+      }
+      if (arg.minLength && arg.maxLength) {
+        parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
       }
+      break;
     }
-    return parts.join(", ");
-  }
-  static createArgument(type) {
-    return function(options) {
-      const objOptions = typeof options === "string" ? { name: options } : options;
-      const fullOptions = { ...objOptions, type };
-      if (!fullOptions.description) {
-        fullOptions.description = fullOptions.name;
+    case "number" /* Number */:
+    case "integer" /* Integer */: {
+      if (arg.minValue !== void 0 && arg.maxValue === void 0) {
+        parts.push(`\u2265 ${String(arg.minValue)}`);
       }
-      if (!("required" in fullOptions)) {
-        fullOptions.required = true;
+      if (arg.minValue === void 0 && arg.maxValue !== void 0) {
+        parts.push(`\u2264 ${String(arg.maxValue)}`);
       }
-      return function(target, key, _index) {
-        const method = Object.getOwnPropertyDescriptor(target, key)?.value;
-        if (!method) {
-          throw new Error("No method found");
-        }
-        const args = _Arg.getMethodArguments(method, true);
-        args.unshift(fullOptions);
-      };
-    };
+      if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
+        parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
+      }
+      break;
+    }
+    case "user" /* User */:
+    case "member" /* Member */: {
+      break;
+    }
   }
+  return parts.join(", ");
+}
+function format(arg) {
+  const { name, required, tuple } = arg;
+  const opening = required ? "<" : "[";
+  const closing = required ? ">" : "]";
+  const prefix = tuple ? "..." : "";
+  return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
+}
+var Arg = {
+  getMethodArguments,
+  createArgument,
+  describeArgumentExpectation,
+  format,
+  string,
+  number,
+  integer,
+  user,
+  member
 };
 
 // src/command/CommandEntry.ts
@@ -221,25 +230,27 @@ var SubcommandEntry = class extends BaseCommandEntry {
 
 // src/command/Command.ts
 var ROOT_KEY = Symbol("root");
-var Command = class {
-  static create(options) {
-    if (typeof options === "string") {
-      options = { name: options };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    return new RootCommandEntry(options);
-  }
-  static use(command) {
-    return (target) => {
-      Reflect.defineMetadata(ROOT_KEY, command, target);
-    };
-  }
-  static getRoot(constructor) {
-    return Reflect.getMetadata(ROOT_KEY, constructor);
-  }
-};
+function use(command) {
+  return (target) => {
+    Reflect.defineMetadata(ROOT_KEY, command, target);
+  };
+}
+function getRoot(constructor) {
+  return Reflect.getMetadata(ROOT_KEY, constructor);
+}
+function CommandFactory(options) {
+  if (typeof options === "string") {
+    options = { name: options };
+  }
+  if (!options.description) {
+    options.description = options.name;
+  }
+  return new RootCommandEntry(options);
+}
+var Command = Object.assign(CommandFactory, {
+  use,
+  getRoot
+});
 
 // src/command/CommandRegistry.ts
 import {
@@ -454,11 +465,14 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandFactory,
   CommandGroupEntry,
   CommandRegistry,
   HOOKS_KEY,
   HookExecutionState,
   MessageContext,
   RootCommandEntry,
-  SubcommandEntry
+  SubcommandEntry,
+  getRoot,
+  use
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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, t as BaseContext, u as ChatInputContext, q as ChatInputContextSendOptions, o as Command, n as CommandConstructor, m as CommandEntry, k as CommandGroupEntry, e as CommandHook, C as CommandHookMethod, p as CommandRegistry, z as CommandSyntaxError, y as CommandSyntaxErrorOptions, x as CommandSyntaxErrorType, w as Context, s as ContextSendOptions, g as CreateOptions, G as GetSyntaxErrorMessageFunction, h as HOOKS_KEY, H as HookExecutionState, I as IntegerArgumentOptions, M as MemberArgumentOptions, v as MessageContext, r as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions } from './BakitClient-BWxRFtSg.js';
+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 { AsyncLocalStorage } from 'node:async_hooks';
 import 'discord.js';
 import 'type-fest';

package/dist/index.js

@@ -30,86 +30,95 @@ var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
 
 // src/command/argument/Arg.ts
 var ARGS_KEY = Symbol("args");
-var Arg = class _Arg {
-  static cache = /* @__PURE__ */ new WeakMap();
-  static string = _Arg.createArgument("string" /* String */);
-  static integer = _Arg.createArgument("integer" /* Integer */);
-  static number = _Arg.createArgument("number" /* Number */);
-  static user = _Arg.createArgument("user" /* User */);
-  static member = _Arg.createArgument("member" /* Member */);
-  static getMethodArguments(method, init = false) {
-    let args = this.cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
-    if (!args) {
-      args = [];
-      if (init) {
-        Reflect.defineMetadata(ARGS_KEY, args, method);
-        this.cache.set(method, args);
-      }
+var cache = /* @__PURE__ */ new WeakMap();
+function getMethodArguments(method, init = false) {
+  let args = cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
+  if (!args) {
+    args = [];
+    if (init) {
+      Reflect.defineMetadata(ARGS_KEY, args, method);
+      cache.set(method, args);
     }
-    return init ? args : Object.freeze([...args]);
   }
-  static format(arg) {
-    const { name, required, tuple } = arg;
-    const opening = required ? "<" : "[";
-    const closing = required ? ">" : "]";
-    const prefix = tuple ? "..." : "";
-    return `${opening}${prefix}${name}: ${this.describeArgumentExpectation(arg)}${closing}`;
-  }
-  static describeArgumentExpectation(arg) {
-    const parts = [arg.type];
-    switch (arg.type) {
-      case "string" /* String */: {
-        if (arg.minLength && !arg.maxLength) {
-          parts.push(`\u2265 ${String(arg.minLength)}`);
-        }
-        if (!arg.minLength && arg.maxLength) {
-          parts.push(`\u2264 ${String(arg.maxLength)}`);
-        }
-        if (arg.minLength && arg.maxLength) {
-          parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
-        }
-        break;
+  return init ? args : Object.freeze([...args]);
+}
+function createArgument(type) {
+  return function(options) {
+    const objOptions = typeof options === "string" ? { name: options } : options;
+    const fullOptions = { ...objOptions, type };
+    if (!fullOptions.description) {
+      fullOptions.description = fullOptions.name;
+    }
+    if (!("required" in fullOptions)) {
+      fullOptions.required = true;
+    }
+    return function(target, key, _index) {
+      const method = Object.getOwnPropertyDescriptor(target, key)?.value;
+      if (!method) {
+        throw new Error("No method found");
       }
-      case "number" /* Number */:
-      case "integer" /* Integer */: {
-        if (arg.minValue !== void 0 && arg.maxValue === void 0) {
-          parts.push(`\u2265 ${String(arg.minValue)}`);
-        }
-        if (arg.minValue === void 0 && arg.maxValue !== void 0) {
-          parts.push(`\u2264 ${String(arg.maxValue)}`);
-        }
-        if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
-          parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
-        }
-        break;
+      const args = getMethodArguments(method, true);
+      args.unshift(fullOptions);
+    };
+  };
+}
+var string = createArgument("string" /* String */);
+var integer = createArgument("integer" /* Integer */);
+var number = createArgument("number" /* Number */);
+var user = createArgument("user" /* User */);
+var member = createArgument("member" /* Member */);
+function describeArgumentExpectation(arg) {
+  const parts = [arg.type];
+  switch (arg.type) {
+    case "string" /* String */: {
+      if (arg.minLength && !arg.maxLength) {
+        parts.push(`\u2265 ${String(arg.minLength)}`);
       }
-      case "user" /* User */:
-      case "member" /* Member */: {
-        break;
+      if (!arg.minLength && arg.maxLength) {
+        parts.push(`\u2264 ${String(arg.maxLength)}`);
       }
+      if (arg.minLength && arg.maxLength) {
+        parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
+      }
+      break;
     }
-    return parts.join(", ");
-  }
-  static createArgument(type) {
-    return function(options) {
-      const objOptions = typeof options === "string" ? { name: options } : options;
-      const fullOptions = { ...objOptions, type };
-      if (!fullOptions.description) {
-        fullOptions.description = fullOptions.name;
+    case "number" /* Number */:
+    case "integer" /* Integer */: {
+      if (arg.minValue !== void 0 && arg.maxValue === void 0) {
+        parts.push(`\u2265 ${String(arg.minValue)}`);
       }
-      if (!("required" in fullOptions)) {
-        fullOptions.required = true;
+      if (arg.minValue === void 0 && arg.maxValue !== void 0) {
+        parts.push(`\u2264 ${String(arg.maxValue)}`);
       }
-      return function(target, key, _index) {
-        const method = Object.getOwnPropertyDescriptor(target, key)?.value;
-        if (!method) {
-          throw new Error("No method found");
-        }
-        const args = _Arg.getMethodArguments(method, true);
-        args.unshift(fullOptions);
-      };
-    };
+      if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
+        parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
+      }
+      break;
+    }
+    case "user" /* User */:
+    case "member" /* Member */: {
+      break;
+    }
   }
+  return parts.join(", ");
+}
+function format(arg) {
+  const { name, required, tuple } = arg;
+  const opening = required ? "<" : "[";
+  const closing = required ? ">" : "]";
+  const prefix = tuple ? "..." : "";
+  return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
+}
+var Arg = {
+  getMethodArguments,
+  createArgument,
+  describeArgumentExpectation,
+  format,
+  string,
+  number,
+  integer,
+  user,
+  member
 };
 
 // src/command/CommandEntry.ts
@@ -237,25 +246,27 @@ var SubcommandEntry = class extends BaseCommandEntry {
 
 // src/command/Command.ts
 var ROOT_KEY = Symbol("root");
-var Command = class {
-  static create(options) {
-    if (typeof options === "string") {
-      options = { name: options };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    return new RootCommandEntry(options);
-  }
-  static use(command) {
-    return (target) => {
-      Reflect.defineMetadata(ROOT_KEY, command, target);
-    };
+function use(command) {
+  return (target) => {
+    Reflect.defineMetadata(ROOT_KEY, command, target);
+  };
+}
+function getRoot(constructor) {
+  return Reflect.getMetadata(ROOT_KEY, constructor);
+}
+function CommandFactory(options) {
+  if (typeof options === "string") {
+    options = { name: options };
   }
-  static getRoot(constructor) {
-    return Reflect.getMetadata(ROOT_KEY, constructor);
+  if (!options.description) {
+    options.description = options.name;
   }
-};
+  return new RootCommandEntry(options);
+}
+var Command = Object.assign(CommandFactory, {
+  use,
+  getRoot
+});
 
 // src/command/CommandRegistry.ts
 var CommandRegistry = class _CommandRegistry {
@@ -699,11 +710,11 @@ var ArgumentResolver = class _ArgumentResolver {
     if (!userId) {
       return null;
     }
-    const user = await this.client.users.fetch(userId).catch(() => null);
-    if (!user) {
+    const user2 = await this.client.users.fetch(userId).catch(() => null);
+    if (!user2) {
       return null;
     }
-    return user;
+    return user2;
   }
   matchIntegerValue(arg, value) {
     const intVal = parseInt(value, 10);
@@ -1006,6 +1017,7 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandFactory,
   CommandGroupEntry,
   CommandRegistry,
   CommandSyntaxError,
@@ -1016,5 +1028,7 @@ export {
   RootCommandEntry,
   StateBox,
   SubcommandEntry,
-  extractId
+  extractId,
+  getRoot,
+  use
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "1.0.0-beta.1",
+	"version": "1.0.0-beta.2",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {
@@ -12,8 +12,7 @@
 	"scripts": {
 		"build": "tsup",
 		"type-check": "tsc --noEmit",
-		"test": "vitest run --pass-with-no-tests",
-		"prepare": "husky"
+		"test": "vitest run --pass-with-no-tests"
 	},
 	"files": [
 		"dist"
@@ -30,25 +29,6 @@
 	"peerDependencies": {
 		"discord.js": "^14.0.0"
 	},
-	"devDependencies": {
-		"@eslint/js": "^9.34.0",
-		"@types/node": "^24.3.0",
-		"@vitest/ui": "^3.2.4",
-		"discord.js": "^14.22.1",
-		"dotenv": "^17.2.1",
-		"eslint": "^9.34.0",
-		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-prettier": "^5.5.4",
-		"husky": "^9.1.7",
-		"lint-staged": "^16.1.5",
-		"prettier": "^3.6.2",
-		"tsup": "^8.5.0",
-		"tsx": "^4.20.5",
-		"typescript": "^5.9.2",
-		"typescript-eslint": "^8.40.0",
-		"vitest": "^3.2.4",
-		"bakit": "link:../../.local/share/pnpm/global/5/node_modules/bakit"
-	},
 	"dependencies": {
 		"reflect-metadata": "^0.2.2",
 		"tiny-glob": "^0.2.9",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Louis Johnson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,2 +0,0 @@
-# bakit
-A discord.js framework