bakit 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as discord_js from 'discord.js';
-import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client } from 'discord.js';
+import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, Client, ClientEvents } from 'discord.js';
 import z$1, { z } from 'zod';
-import { inspect } from 'node:util';
 import * as jiti from 'jiti';
+import { inspect } from 'node:util';
 
 declare const ProjectConfigSchema: z.ZodObject<{
     intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
@@ -31,6 +31,12 @@ declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
  */
 declare function getConfig(): ProjectConfig;
 
+declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
+
+declare function tokenize(content: string): string[];
+
+declare const $jiti: jiti.Jiti;
+
 declare class Context {
     canceled: boolean;
     cancel(): void;
@@ -103,54 +109,27 @@ declare const BaseParamSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     required: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
-declare const StringParamSchema: z.ZodPipe<z.ZodObject<{
+declare const StringParamSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     required: z.ZodDefault<z.ZodBoolean>;
     maxLength: z.ZodOptional<z.ZodNumber>;
     minLength: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodTransform<{
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-} & {
-    description: string;
-}, {
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-}>>;
-declare const NumberParamSchema: z.ZodPipe<z.ZodObject<{
+}, z.core.$strip>;
+declare const NumberParamSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     required: z.ZodDefault<z.ZodBoolean>;
     maxValue: z.ZodOptional<z.ZodNumber>;
     minValue: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodTransform<{
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxValue?: number | undefined;
-    minValue?: number | undefined;
-} & {
-    description: string;
-}, {
-    name: string;
-    required: boolean;
-    description?: string | undefined;
-    maxValue?: number | undefined;
-    minValue?: number | undefined;
-}>>;
+}, z.core.$strip>;
 type BaseParamOptions = z.input<typeof BaseParamSchema>;
 type StringOptions = z.input<typeof StringParamSchema>;
 type NumberOptions = z.input<typeof NumberParamSchema>;
 
 type ParamResolvedOutputType<OutputType, Required extends boolean = true> = Required extends true ? OutputType : OutputType | null;
 declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
+    private schema;
     options: Options & {
         required: Required;
     };
@@ -163,7 +142,7 @@ declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, R
      * @internal
      */
     readonly _type: Required extends true ? OutputType : OutputType | null;
-    constructor(options: Options);
+    constructor(options: Options, schema: z$1.ZodObject);
     protected setOption(key: keyof Options, value: any): this;
     name(value: string): this;
     description(value: string): this;
@@ -298,11 +277,6 @@ declare function defineCommand<const ParamsList extends readonly AnyParam<any>[]
     params?: ParamsList;
 }) | string): Command<ParamsList>;
 
-declare class BaseClientManager {
-    client: BakitClient;
-    constructor(client: BakitClient);
-}
-
 declare class CommandManager extends BaseClientManager {
     commands: Collection<string, Command<any[]>>;
     loadModules(): Promise<Command[]>;
@@ -337,17 +311,39 @@ declare class ListenerManager extends BaseClientManager {
     getNeededIntents(): IntentsBitField;
 }
 
+declare class ProjectCacheManager {
+    private readonly rootDir;
+    constructor(root?: string);
+    private ensureRoot;
+    getHash(data: unknown): string;
+    write(path: string, data: unknown): Promise<void>;
+    read<T>(path: string): Promise<T | null>;
+    clear(): Promise<void>;
+    clearSync(): void;
+}
+
+declare class Instance {
+    client: BakitClient;
+    cache: ProjectCacheManager;
+    constructor();
+    start(): Promise<void>;
+    private loadModules;
+    private initIntents;
+}
+declare function useApp(): Instance;
+
 type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
 interface BakitClientEvents extends ClientEvents {
     ready: [BakitClient<true>];
     clientReady: [BakitClient<true>];
 }
 declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready> {
+    instance: Instance;
     managers: {
         commands: CommandManager;
         listeners: ListenerManager;
     };
-    constructor(options: ClientOptions);
+    constructor(options: ClientOptions, instance: Instance);
     /**
      * Check if the client is connected to gateway successfully and finished initialization.
      */
@@ -365,28 +361,9 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     [inspect.custom](): string;
 }
 
-declare class Instance {
+declare class BaseClientManager {
     client: BakitClient;
-    start(): Promise<void>;
-    private loadModules;
-    private initIntents;
-}
-declare function useApp(): Instance;
-
-declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
-
-declare function tokenize(content: string): string[];
-
-declare const $jiti: jiti.Jiti;
-
-declare class BakitError extends Error {
-    constructor(message: string);
-}
-
-declare class ArgumentError extends BakitError {
-    target: string;
-    reason: string;
-    constructor(target: string, reason: string);
+    constructor(client: BakitClient);
 }
 
 declare const Params: {
@@ -406,4 +383,14 @@ declare const Params: {
     }) => NumberParam<Required>;
 };
 
+declare class BakitError extends Error {
+    constructor(message: string);
+}
+
+declare class ArgumentError extends BakitError {
+    target: string;
+    reason: string;
+    constructor(target: string, reason: string);
+}
+
 export { $jiti, type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };

package/dist/index.js

@@ -1,9 +1,12 @@
 import { GatewayIntentBits, Events, Client, IntentsBitField, Collection, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, ChatInputCommandInteraction, Message } from 'discord.js';
-import z3, { z } from 'zod';
+import z4, { z } from 'zod';
 import glob from 'tiny-glob';
 import { createJiti } from 'jiti';
 import { inspect } from 'util';
-import { posix } from 'path';
+import { posix, join, dirname } from 'path';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { mkdir, writeFile, readFile, rm } from 'fs/promises';
+import { createHash } from 'crypto';
 
 // src/config.ts
 var INTENT_GROUPS = {
@@ -178,6 +181,13 @@ function getConfig() {
   return _config;
 }
 
+// src/base/BaseClientManager.ts
+var BaseClientManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+};
+
 // src/base/lifecycle/Context.ts
 var Context = class {
   canceled = false;
@@ -186,7 +196,7 @@ var Context = class {
   }
 };
 
-// src/command/CommandContext.ts
+// src/base/command/CommandContext.ts
 var BaseCommandContext = class extends Context {
   constructor(source) {
     super();
@@ -320,6 +330,17 @@ var HookState = /* @__PURE__ */ ((HookState2) => (HookState2.Pre = "PRE", HookSt
     }
   }
 };
+var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  required: z.boolean().default(true)
+}), StringParamSchema = BaseParamSchema.extend({
+  maxLength: z.number().min(1).optional(),
+  minLength: z.number().min(1).optional()
+}), NumberParamSchema = BaseParamSchema.extend({
+  maxValue: z.number().optional(),
+  minValue: z.number().optional()
+});
 
 // src/errors/BakitError.ts
 var BakitError = class extends Error {
@@ -337,15 +358,26 @@ var ArgumentError = class extends BakitError {
   }
 };
 
-// src/command/param/Param.ts
+// src/base/command/param/Param.ts
 var BaseParam = class {
-  options;
-  constructor(options) {
-    this.options = { ...options, required: options.required ?? true };
+  constructor(options, schema) {
+    this.schema = schema;
+    let parsed = schema.parse({
+      ...options,
+      description: options.description ?? options.name
+    });
+    this.options = parsed;
   }
+  options;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   setOption(key, value) {
-    return value === null ? delete this.options[key] : this.options[key] = value, this;
+    if (value === null)
+      return delete this.options[key], this;
+    let fieldValidator = this.schema.shape[key];
+    if (!fieldValidator)
+      return this.options[key] = value, this;
+    let parsedValue = fieldValidator.parse(value);
+    return this.options[key] = parsedValue, this;
   }
   name(value) {
     return this.setOption("name", value);
@@ -371,7 +403,7 @@ var BaseParam = class {
   }
 }, StringParam = class extends BaseParam {
   constructor(options) {
-    super(BaseParam.getOptions(options));
+    super(BaseParam.getOptions(options), StringParamSchema);
   }
   required(value) {
     return super.required(value);
@@ -409,7 +441,7 @@ var BaseParam = class {
   }
 }, NumberParam = class extends BaseParam {
   constructor(options) {
-    super(BaseParam.getOptions(options));
+    super(BaseParam.getOptions(options), NumberParamSchema);
   }
   required(value) {
     return super.required(value);
@@ -510,14 +542,7 @@ function defineCommand(options) {
   return new Command(options);
 }
 
-// src/base/BaseClientManager.ts
-var BaseClientManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-};
-
-// src/command/CommandManager.ts
+// src/base/command/CommandManager.ts
 var CommandManager = class extends BaseClientManager {
   commands = new Collection();
   async loadModules() {
@@ -561,9 +586,9 @@ var CommandManager = class extends BaseClientManager {
     return this.commands.get(name);
   }
 };
-var ListenerOptionsSchema = z3.object({
-  name: z3.enum(Events),
-  once: z3.boolean().default(false)
+var ListenerOptionsSchema = z4.object({
+  name: z4.enum(Events),
+  once: z4.boolean().default(false)
 }), Listener = class extends LifecycleManager {
   options;
   constructor(options) {
@@ -633,15 +658,17 @@ var ListenerManager = class extends BaseClientManager {
   }
 };
 
-// src/BakitClient.ts
-var BakitClient3 = class extends Client {
-  managers;
-  constructor(options) {
-    super(options), this.managers = {
+// src/base/BakitClient.ts
+var BakitClient2 = class extends Client {
+  constructor(options, instance) {
+    super(options);
+    this.instance = instance;
+    this.managers = {
       commands: new CommandManager(this),
       listeners: new ListenerManager(this)
     };
   }
+  managers;
   /**
    * Check if the client is connected to gateway successfully and finished initialization.
    */
@@ -674,22 +701,8 @@ var BakitClient3 = class extends Client {
     return `${this.constructor.name} {}`;
   }
 };
-var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  required: z.boolean().default(true)
-}), withDefaultDescription = (data) => ({
-  ...data,
-  description: data.description ?? `${data.name}`
-}), StringParamSchema = BaseParamSchema.extend({
-  maxLength: z.number().min(1).optional(),
-  minLength: z.number().min(1).optional()
-}).transform(withDefaultDescription), NumberParamSchema = BaseParamSchema.extend({
-  maxValue: z.number().optional(),
-  minValue: z.number().optional()
-}).transform(withDefaultDescription);
 
-// src/command/param/Params.ts
+// src/base/command/param/Params.ts
 function createFactory(ctor) {
   return (...args) => new ctor(...args);
 }
@@ -704,8 +717,22 @@ var messageCommandHandler = defineListener(Events.MessageCreate), chatInputComma
   once: true
 });
 registerCommandsHandler.main(async (_, client) => {
-  let { commands } = client.managers, data = commands.commands.map((cmd) => cmd.toSlashCommandJSON()), result = await client.application.commands.set(data);
-  console.log(`Registered ${result.size} application command(s)`);
+  let { managers, instance } = client, { commands } = managers, { cache } = instance, payload = commands.commands.map((cmd) => cmd.toSlashCommandJSON()).sort((a, b) => a.name.localeCompare(b.name)), currentHash = cache.getHash(payload), CACHE_KEY = "commands/meta.json", cachedMeta = await cache.read(CACHE_KEY);
+  if (cachedMeta && cachedMeta.hash === currentHash) {
+    let { timestamp, count } = cachedMeta, time = new Date(timestamp).toLocaleString();
+    console.log(`${count} command(s) are up to date (Last sync: ${time}). Skipping registration.`);
+    return;
+  }
+  try {
+    let result = await client.application.commands.set(payload);
+    cache.write(CACHE_KEY, {
+      hash: currentHash,
+      timestamp: Date.now(),
+      count: result.size
+    }), cache.write("commands/debug_dump.json", payload), console.log(`Registered ${result.size} application command(s).`);
+  } catch (error) {
+    console.error("Failed to register commands:", error);
+  }
 });
 messageCommandHandler.main(async (_, message) => {
   let config = getConfig();
@@ -743,20 +770,61 @@ chatInputCommandHandler.main(async (_, interaction) => {
   }
   await command.execute(context, ...resolvedArgs);
 });
+var ProjectCacheManager = class {
+  rootDir;
+  constructor(root = process.cwd()) {
+    this.rootDir = join(root, ".bakit"), this.ensureRoot();
+  }
+  ensureRoot() {
+    existsSync(this.rootDir) || mkdirSync(this.rootDir, { recursive: true });
+  }
+  getHash(data) {
+    return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+  }
+  async write(path, data) {
+    let fullPath = join(this.rootDir, path), dir = dirname(fullPath);
+    await mkdir(dir, { recursive: true });
+    let content = typeof data == "string" ? data : JSON.stringify(data);
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async read(path) {
+    let fullPath = join(this.rootDir, path);
+    try {
+      let content = await readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    await rm(this.rootDir, { recursive: true, force: true });
+  }
+  clearSync() {
+    existsSync(this.rootDir) && rmSync(this.rootDir, { recursive: true, force: true });
+  }
+};
 
-// src/Instance.ts
+// src/base/Instance.ts
 var Instance = class {
   client;
+  cache;
+  constructor() {
+    this.cache = new ProjectCacheManager();
+  }
   async start() {
     await loadConfig();
     let config = getConfig();
-    this.client = new BakitClient3({
-      intents: []
-    }), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
+    this.client = new BakitClient2(
+      {
+        intents: [],
+        ...config.clientOptions
+      },
+      this
+    ), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
   }
   loadModules() {
     let { managers } = this.client, { commands, listeners } = managers;
-    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
+    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), listeners.add(registerCommandsHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
   }
   initIntents() {
     let config = getConfig(), { options, managers } = this.client, { listeners } = managers, intents;
@@ -767,4 +835,4 @@ function useApp() {
   return new Instance();
 }
 
-export { $jiti, ArgumentError, BakitClient3 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };
+export { $jiti, ArgumentError, BakitClient2 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "2.0.0-alpha.7",
+	"version": "2.0.0-alpha.9",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"types": "./dist/index.d.ts",