bakit 2.0.0-alpha.16 → 2.0.0-alpha.18

package/dist/cli.js

@@ -3,15 +3,12 @@ import { program } from 'commander';
 import { fork } from 'child_process';
 import chokidar from 'chokidar';
 import path, { relative, sep } from 'path';
-import { createJiti } from 'jiti';
+import { pathToFileURL } from 'url';
 
 // src/cli/bin.ts
-createJiti(process.cwd());
 function getTopLevelDirectory(path2, entryDir) {
   return relative(entryDir, path2).split(sep)[0] ?? null;
 }
-
-// src/cli/process/DevProcessManager.ts
 var DevProcessManager = class {
   constructor(options) {
     this.options = options;
@@ -25,7 +22,7 @@ var DevProcessManager = class {
     if (this.child) return;
     let entry = path.resolve(this.options.entry);
     this.child = fork(entry, {
-      execArgv: ["--import", "tsx"],
+      execArgv: ["--import", "bakit/loader/register"],
       stdio: "inherit",
       env: {
         ...process.env,
@@ -51,7 +48,9 @@ var DevProcessManager = class {
         stabilityThreshold: 200,
         pollInterval: 50
       }
-    }).on("change", (file) => this.onFileChanged(file));
+    }).on("change", (file) => {
+      this.onFileChanged(pathToFileURL(file).href);
+    });
   }
   onFileChanged(file) {
     if (!this.child)

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as discord_js from 'discord.js';
-import { ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client, ClientOptions } from 'discord.js';
+import { ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client, ClientOptions, GatewayIntentBits } from 'discord.js';
 import { inspect } from 'node:util';
 import z from 'zod';
 
@@ -447,13 +447,36 @@ declare function tokenize(content: string): string[];
  */
 declare function extractSnowflakeId(input: string): string | null;
 
-declare function importModule<T>(modulePath: string, defaultImport?: boolean): Promise<T | null>;
-declare function isModuleLoaded(modulePath: string): boolean;
-declare function unloadModule(modulePath: string): boolean;
 declare function getTopLevelDirectory(path: string, entryDir: string): string | null;
 
 declare const messageCommandHandler: Listener<Events.MessageCreate>;
 declare const chatInputCommandHandler: Listener<Events.InteractionCreate>;
 declare const registerCommandsHandler: Listener<Events.ClientReady>;
 
-export { 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, ProjectCacheManager, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineListener, extractSnowflakeId, getTopLevelDirectory, importModule, isModuleLoaded, messageCommandHandler, registerCommandsHandler, tokenize, unloadModule, useApp, validateParamsOrder };
+declare const ProjectConfigSchema: z.ZodObject<{
+    intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
+    clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
+    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    token: z.ZodString;
+}, z.z.core.$strip>;
+type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
+type ProjectConfig = z.output<typeof ProjectConfigSchema>;
+/**
+ * Define config object for your project. This is just a cleaner way to define config.
+ * @param config The partial version of project config.
+ * @returns The same config you provided earlier.
+ */
+declare function defineConfig(config: ProjectConfigInput): ProjectConfigInput;
+/**
+ * Load the config file and save them for later usage.
+ * @param cwd The location of the config file, uses root by default.
+ * @returns The complete config with default values from the validation.
+ */
+declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
+/**
+ * Get the loaded config of the project.
+ * @returns The project config.
+ */
+declare function getConfig(): ProjectConfig;
+
+export { 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, ProjectCacheManager, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };

package/dist/index.js

@@ -1,14 +1,42 @@
+import { register } from 'module';
+import { posix, resolve, relative, sep, join, dirname } from 'path';
+import { pathToFileURL } from 'url';
+import { MessageChannel } from 'worker_threads';
 import { GatewayIntentBits, Events, Client, Collection, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
 import { inspect } from 'util';
-import { posix, resolve, relative, sep, join, dirname } from 'path';
 import glob from 'tiny-glob';
 import z4 from 'zod';
-import { createJiti } from 'jiti';
 import { existsSync, mkdirSync, rmSync } from 'fs';
 import { mkdir, writeFile, readFile, rm } from 'fs/promises';
 import { createHash } from 'crypto';
 
-// src/core/client/BakitClient.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/loader/register.ts
+var register_exports = {};
+__export(register_exports, {
+  unload: () => unload
+});
+function unload(module) {
+  port2.postMessage({ type: "unload", target: module });
+}
+var port1, port2, hookPath, init_register = __esm({
+  "src/loader/register.ts"() {
+    (({ port1, port2 } = new MessageChannel())), hookPath = pathToFileURL(resolve("./loader.js")).href;
+    register(hookPath, import.meta.url, {
+      data: { port: port1 },
+      transferList: [port1]
+    });
+  }
+});
 var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z4.object({
   name: z4.string(),
   description: z4.string().optional(),
@@ -159,23 +187,6 @@ function extractSnowflakeId(input) {
   let idMatch = /^(\d{17,20})$/.exec(input);
   return idMatch?.[1] ? idMatch[1] : null;
 }
-var jiti = createJiti(process.cwd());
-async function importModule(modulePath, defaultImport = false) {
-  let path = resolve(modulePath);
-  try {
-    return await jiti.import(path, { default: defaultImport });
-  } catch (error) {
-    return console.error(`[Module] Import failed for ${path}:`, error), null;
-  }
-}
-function isModuleLoaded(modulePath) {
-  let path = resolve(modulePath);
-  return !!path && !!jiti.cache[path];
-}
-function unloadModule(modulePath) {
-  let path = resolve(modulePath);
-  return !path || !jiti.cache[path] ? false : (delete jiti.cache[path], true);
-}
 function getTopLevelDirectory(path, entryDir) {
   return relative(entryDir, path).split(sep)[0] ?? null;
 }
@@ -476,7 +487,7 @@ var CommandManager = class extends BaseClientManager {
    * @returns The command object if added successfully.
    */
   async load(path) {
-    let command = await importModule(path, true);
+    let command = (await import(path)).default;
     if (!command) {
       console.warn(`[Loader] File has no default export: ${path}`);
       return;
@@ -494,7 +505,7 @@ var CommandManager = class extends BaseClientManager {
    */
   async unload(path) {
     let command = this.entries.get(path);
-    if (isModuleLoaded(path) && (command ??= await importModule(path, true), unloadModule(path)), this.entries.delete(path), !!command)
+    if (this.entries.delete(path), (await Promise.resolve().then(() => (init_register(), register_exports))).unload(path), !!command)
       return this.remove(command);
   }
   async reload(path) {
@@ -575,7 +586,7 @@ var ListenerManager = class extends BaseClientManager {
    * @returns The listener object if added successfully.
    */
   async load(path) {
-    let listener = await importModule(path, true);
+    let listener = (await import(path)).default;
     if (!listener) {
       console.warn(`[Loader] File has no default export: ${path}`);
       return;
@@ -593,7 +604,7 @@ var ListenerManager = class extends BaseClientManager {
    */
   async unload(path) {
     let listener = this.entries.get(path);
-    if (isModuleLoaded(path) && (listener ??= await importModule(path, true), unloadModule(path)), this.entries.delete(path), !!listener)
+    if (this.entries.delete(path), (await Promise.resolve().then(() => (init_register(), register_exports))).unload(path), !!listener)
       return this.remove(listener)?.[0];
   }
   async reload(path) {
@@ -778,6 +789,9 @@ var ProjectConfigSchema = z4.object({
   prefixes: z4.array(z4.string()).default([]),
   token: z4.string()
 });
+function defineConfig(config) {
+  return config;
+}
 var _config;
 async function loadConfig(cwd = process.cwd()) {
   if (_config)
@@ -790,7 +804,7 @@ async function loadConfig(cwd = process.cwd()) {
   if (!configPath)
     throw new Error("Missing config file");
   other && console.warn(`Multiple config files found in ${cwd}. Using ${configPath}.`);
-  let config = await importModule(configPath, true);
+  let config = (await import(configPath)).default;
   return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
 }
 function getConfig() {
@@ -949,4 +963,4 @@ var Params = {
   user: createFactory(UserParam)
 };
 
-export { ArgumentError, 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, ProjectCacheManager, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineListener, extractSnowflakeId, getTopLevelDirectory, importModule, isModuleLoaded, messageCommandHandler, registerCommandsHandler, tokenize, unloadModule, useApp, validateParamsOrder };
+export { ArgumentError, 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, ProjectCacheManager, ProjectConfigSchema, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };