reciple 9.9.0 → 10.0.1-dev.0

package/dist/classes/cli/ConfigReader.d.mts

@@ -0,0 +1,81 @@
+import { CLI } from "./CLI.mjs";
+import { BuildConfig } from "../../helpers/types.mjs";
+import { ModuleLoader } from "../client/ModuleLoader.mjs";
+import { ModuleManager } from "../managers/ModuleManager.mjs";
+import { EventListeners } from "../client/EventListeners.mjs";
+import { Logger } from "prtyprnt";
+import { Client, Config } from "@reciple/core";
+import { Options } from "unrun";
+import { UserConfig } from "tsdown";
+
+//#region src/classes/cli/ConfigReader.d.ts
+declare module "@reciple/core" {
+  interface Config {
+    token?: string;
+    modules?: ModuleLoader.Config;
+    logger?: Logger | Logger.Options;
+  }
+  interface Client {
+    readonly modules: ModuleManager;
+    readonly moduleLoader: ModuleLoader;
+    readonly eventListeners: EventListeners;
+    readonly cli: CLI;
+    logger: Logger;
+  }
+}
+declare class ConfigReader {
+  readonly filepath: string;
+  private _client;
+  private _config;
+  private _build;
+  get client(): Client<boolean>;
+  get config(): Config;
+  get build(): UserConfig;
+  constructor(filepath: string);
+  read(options?: Omit<ConfigReader.ReadOptions, 'filepath'>): Promise<ConfigReader>;
+  create(options?: Omit<ConfigReader.CreateOptions, 'filepath'>): Promise<ConfigReader>;
+  exists(): Promise<boolean>;
+  static create(options: ConfigReader.CreateOptions): Promise<ConfigReader>;
+  static hasFile(filepath: string): Promise<boolean>;
+  static findConfig(directory: string, type?: 'ts' | 'js'): Promise<string | null>;
+  static getDefaultContent(type?: 'ts' | 'js'): Promise<string>;
+}
+declare namespace ConfigReader {
+  function getProjectLang(dir: string): Promise<'ts' | 'js'>;
+  interface Structure {
+    client: Client;
+    config: Config;
+  }
+  interface ReadOptions extends Options {
+    createIfNotExists?: boolean;
+    createOptions?: Omit<CreateOptions, 'path'>;
+  }
+  interface CreateOptions {
+    filepath: string;
+    overwrite?: boolean;
+    throwOnConflict?: boolean;
+    type?: 'ts' | 'js';
+    readOptions?: Omit<ReadOptions, ''>;
+  }
+  const FileTypes: {
+    ts: string[];
+    js: string[];
+  };
+  const defaultConfigFilePaths: {
+    ts: string;
+    js: string;
+  };
+  const defaultConfigFilenames: string[];
+  function normalizeTsdownConfig({
+    type,
+    overrides
+  }?: {
+    type?: 'ts' | 'js';
+    overrides?: BuildConfig;
+  }): UserConfig;
+  function createConfigFilename(type: 'ts' | 'js', esm?: boolean): string;
+  function getLangTypeFromFilename(filename: string): 'ts' | 'js' | null;
+}
+//#endregion
+export { ConfigReader };
+//# sourceMappingURL=ConfigReader.d.mts.map

package/dist/classes/cli/ConfigReader.mjs

@@ -0,0 +1,141 @@
+import { CLI } from "./CLI.mjs";
+import path from "node:path";
+import { colors } from "@reciple/utils";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { Client, RecipleError } from "@reciple/core";
+import { unrun } from "unrun";
+import { resolveTSConfig } from "pkg-types";
+
+//#region src/classes/cli/ConfigReader.ts
+var ConfigReader = class ConfigReader {
+	_client = null;
+	_config = null;
+	_build = null;
+	get client() {
+		if (!this._client) throw new RecipleError("client is not yet loaded from config.");
+		return this._client;
+	}
+	get config() {
+		return this._config ?? {};
+	}
+	get build() {
+		return ConfigReader.normalizeTsdownConfig({ overrides: this._build ?? {} });
+	}
+	constructor(filepath) {
+		this.filepath = filepath;
+	}
+	async read(options) {
+		if (!await ConfigReader.hasFile(this.filepath) && options?.createIfNotExists !== false) return ConfigReader.create({
+			filepath: this.filepath,
+			readOptions: options
+		});
+		const { module } = await unrun({
+			...options,
+			path: this.filepath
+		});
+		if (!module || !module.client || !(module.client instanceof Client)) throw new RecipleError(`exported client is not an instance of ${colors.cyan("Client")} from ${colors.green("\"@reciple/core\"")}.`);
+		this._client = module.client;
+		this._config = module.config;
+		this._build = module.build;
+		return this;
+	}
+	async create(options) {
+		return ConfigReader.create({
+			...options,
+			filepath: this.filepath
+		});
+	}
+	async exists() {
+		return await ConfigReader.hasFile(this.filepath);
+	}
+	static async create(options) {
+		const type = options.type ?? ConfigReader.getLangTypeFromFilename(options.filepath) ?? "js";
+		if (await ConfigReader.hasFile(options.filepath) && !options.overwrite) {
+			if (options.throwOnConflict !== false) throw new RecipleError(`config file already exists at ${colors.green(options.filepath)}`);
+			const reader$1 = new ConfigReader(options.filepath);
+			await reader$1.read(options.readOptions);
+			return reader$1;
+		}
+		await mkdir(path.dirname(options.filepath), { recursive: true });
+		await writeFile(options.filepath, await this.getDefaultContent(type));
+		const reader = new ConfigReader(options.filepath);
+		await reader.read(options.readOptions);
+		return reader;
+	}
+	static async hasFile(filepath) {
+		return stat(filepath).then((s) => s.isFile()).catch(() => false);
+	}
+	static async findConfig(directory, type) {
+		const validFiles = ConfigReader.defaultConfigFilenames.filter((f) => type ? ConfigReader.FileTypes[type].includes(f) : true);
+		const files = (await readdir(directory)).find((f) => validFiles.includes(f));
+		return files ? path.join(directory, files) : null;
+	}
+	static async getDefaultContent(type = "js") {
+		const filepath = ConfigReader.defaultConfigFilePaths[type];
+		return await readFile(filepath, "utf-8");
+	}
+};
+(function(_ConfigReader) {
+	async function getProjectLang(dir) {
+		const hasTsConfig = !!await resolveTSConfig(dir, { try: true });
+		const configLangIsTypescript = (await ConfigReader.findConfig(dir).then((f) => f ?? "")).endsWith("ts");
+		return hasTsConfig || configLangIsTypescript ? "ts" : "js";
+	}
+	_ConfigReader.getProjectLang = getProjectLang;
+	const FileTypes = _ConfigReader.FileTypes = {
+		ts: [
+			"ts",
+			"mts",
+			"tsx"
+		],
+		js: [
+			"js",
+			"mjs",
+			"jsx"
+		]
+	};
+	_ConfigReader.defaultConfigFilePaths = {
+		ts: path.join(CLI.root, "assets/config", `reciple.config.ts`),
+		js: path.join(CLI.root, "assets/config", `reciple.config.js`)
+	};
+	_ConfigReader.defaultConfigFilenames = [
+		"reciple.config.ts",
+		"reciple.config.mts",
+		"reciple.config.js",
+		"reciple.config.mjs"
+	];
+	function normalizeTsdownConfig({ type, overrides } = {}) {
+		return {
+			entry: [`./src/**/*.{ts,tsx,js,jsx}`],
+			outDir: "./modules",
+			tsconfig: `./${type ?? "ts"}config.json`,
+			external: [],
+			noExternal: [],
+			sourcemap: true,
+			treeshake: true,
+			clean: true,
+			...overrides,
+			watch: false,
+			platform: "node",
+			format: "esm",
+			unbundle: true,
+			skipNodeModulesBundle: true
+		};
+	}
+	_ConfigReader.normalizeTsdownConfig = normalizeTsdownConfig;
+	function createConfigFilename(type, esm = false) {
+		return `reciple.config.${type === "ts" ? esm ? "mts" : "ts" : esm ? "mjs" : "js"}`;
+	}
+	_ConfigReader.createConfigFilename = createConfigFilename;
+	function getLangTypeFromFilename(filename) {
+		const extention = path.extname(filename).slice(1);
+		if (FileTypes.ts.includes(extention)) return "ts";
+		if (FileTypes.js.includes(extention)) return "js";
+		return null;
+	}
+	_ConfigReader.getLangTypeFromFilename = getLangTypeFromFilename;
+})(ConfigReader || (ConfigReader = {}));
+
+//#endregion
+export { ConfigReader };
+//# sourceMappingURL=ConfigReader.mjs.map

package/dist/classes/cli/ConfigReader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigReader.mjs","names":["filepath: string","reader"],"sources":["../../../src/classes/cli/ConfigReader.ts"],"sourcesContent":["import { Client, RecipleError, type Config } from '@reciple/core';\nimport { colors } from '@reciple/utils';\nimport { CLI } from './CLI.js';\nimport path from 'node:path';\nimport { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';\nimport type { ModuleLoader } from '../client/ModuleLoader.js';\nimport type { Logger } from 'prtyprnt';\nimport type { ModuleManager } from '../managers/ModuleManager.js';\nimport type { BuildConfig } from '../../helpers/types.js';\nimport type { EventListeners } from '../client/EventListeners.js';\nimport type { UserConfig } from 'tsdown';\nimport { unrun, type Options } from 'unrun';\nimport { resolveTSConfig } from 'pkg-types';\n\ndeclare module \"@reciple/core\" {\n    interface Config {\n        token?: string;\n        modules?: ModuleLoader.Config;\n        logger?: Logger|Logger.Options;\n    }\n\n    interface Client {\n        readonly modules: ModuleManager;\n        readonly moduleLoader: ModuleLoader;\n        readonly eventListeners: EventListeners;\n        readonly cli: CLI;\n        logger: Logger;\n    }\n}\n\nexport class ConfigReader {\n    private _client: Client|null = null;\n    private _config: Config|null = null;\n    private _build: BuildConfig|null = null;\n\n    get client() {\n        if (!this._client) throw new RecipleError('client is not yet loaded from config.');\n        return this._client;\n    }\n\n    get config() {\n        return this._config ?? {};\n    }\n\n    get build() {\n        return ConfigReader.normalizeTsdownConfig({\n            overrides: this._build ?? {}\n        });\n    }\n\n    constructor(public readonly filepath: string) {}\n\n    public async read(options?: Omit<ConfigReader.ReadOptions, 'filepath'>): Promise<ConfigReader> {\n        if (!await ConfigReader.hasFile(this.filepath) && options?.createIfNotExists !== false) return ConfigReader.create({\n            filepath: this.filepath,\n            readOptions: options\n        });\n\n        const { module } = await unrun<Config>({ ...options, path: this.filepath });\n\n        if (!module || !module.client || !(module.client instanceof Client)) {\n            throw new RecipleError(`exported client is not an instance of ${colors.cyan('Client')} from ${colors.green('\"@reciple/core\"')}.`);\n        }\n\n        this._client = module.client;\n        this._config = module.config;\n        this._build = module.build;\n\n        return this;\n    }\n\n    public async create(options?: Omit<ConfigReader.CreateOptions, 'filepath'>): Promise<ConfigReader> {\n        return ConfigReader.create({ ...options, filepath: this.filepath });\n    }\n\n    public async exists(): Promise<boolean> {\n        return await ConfigReader.hasFile(this.filepath);\n    }\n\n    public static async create(options: ConfigReader.CreateOptions): Promise<ConfigReader> {\n        const type = options.type ?? ConfigReader.getLangTypeFromFilename(options.filepath) ?? 'js';\n\n        if (await ConfigReader.hasFile(options.filepath) && !options.overwrite) {\n            if (options.throwOnConflict !== false) throw new RecipleError(`config file already exists at ${colors.green(options.filepath)}`);\n\n            const reader = new ConfigReader(options.filepath);\n            await reader.read(options.readOptions);\n            return reader;\n        }\n\n        await mkdir(path.dirname(options.filepath), { recursive: true });\n        await writeFile(options.filepath, await this.getDefaultContent(type));\n\n        const reader = new ConfigReader(options.filepath);\n\n        await reader.read(options.readOptions);\n        return reader;\n    }\n\n    public static async hasFile(filepath: string): Promise<boolean> {\n        return stat(filepath)\n            .then(s => s.isFile())\n            .catch(() => false);\n    }\n\n    public static async findConfig(directory: string, type?: 'ts'|'js'): Promise<string|null> {\n        const validFiles = ConfigReader.defaultConfigFilenames.filter(f => type ? ConfigReader.FileTypes[type].includes(f) : true);\n        const files = (await readdir(directory)).find(f => validFiles.includes(f));\n        return files ? path.join(directory, files) : null;\n    }\n\n    public static async getDefaultContent(type: 'ts'|'js' = 'js'): Promise<string> {\n        const filepath = ConfigReader.defaultConfigFilePaths[type];\n        const content = await readFile(filepath, 'utf-8');\n        return content;\n    }\n}\n\nexport namespace ConfigReader {\n    export async function getProjectLang(dir: string): Promise<'ts'|'js'> {\n        const hasTsConfig = !!await resolveTSConfig(dir, { try: true });\n        const configLangIsTypescript = (await ConfigReader.findConfig(dir).then(f => f ?? '')).endsWith('ts');\n\n        return hasTsConfig || configLangIsTypescript ? 'ts' : 'js';\n    }\n\n    export interface Structure {\n        client: Client;\n        config: Config;\n    }\n\n    export interface ReadOptions extends Options {\n        createIfNotExists?: boolean;\n        createOptions?: Omit<CreateOptions, 'path'>;\n    }\n\n    export interface CreateOptions {\n        filepath: string;\n        overwrite?: boolean;\n        throwOnConflict?: boolean;\n        type?: 'ts' | 'js';\n        readOptions?: Omit<ReadOptions, ''>;\n    }\n\n    export const FileTypes = {\n        ts: ['ts', 'mts', 'tsx'],\n        js: ['js', 'mjs', 'jsx']\n    };\n\n    export const defaultConfigFilePaths = {\n        ts: path.join(CLI.root, 'assets/config', `reciple.config.ts`),\n        js: path.join(CLI.root, 'assets/config', `reciple.config.js`)\n    };\n\n    export const defaultConfigFilenames = [\n        'reciple.config.ts',\n        'reciple.config.mts',\n        'reciple.config.js',\n        'reciple.config.mjs'\n    ];\n\n    export function normalizeTsdownConfig({ type, overrides }: { type?: 'ts' | 'js', overrides?: BuildConfig; } = {}): UserConfig {\n        return {\n            entry: [`./src/**/*.{ts,tsx,js,jsx}`],\n            outDir: './modules',\n            tsconfig: `./${type ?? 'ts'}config.json`,\n            external: [],\n            noExternal: [],\n            sourcemap: true,\n            treeshake: true,\n            clean: true,\n            ...overrides,\n            watch: false,\n            platform: 'node',\n            format: 'esm',\n            unbundle: true,\n            skipNodeModulesBundle: true\n        };\n    }\n\n    export function createConfigFilename(type: 'ts'|'js', esm: boolean = false): string {\n        return `reciple.config.${type === 'ts' ? esm ? 'mts' : 'ts' : esm ? 'mjs' : 'js'}`;\n    }\n\n    export function getLangTypeFromFilename(filename: string): 'ts'|'js'|null {\n        const extention = path.extname(filename).slice(1);\n\n        if (FileTypes.ts.includes(extention)) return 'ts';\n        if (FileTypes.js.includes(extention)) return 'js';\n        return null;\n    }\n}\n"],"mappings":"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"}

package/dist/classes/cli/RuntimeEnvironment.d.mts

@@ -0,0 +1,14 @@
+import { Client } from "@reciple/core";
+
+//#region src/classes/cli/RuntimeEnvironment.d.ts
+declare class RuntimeEnvironment {}
+declare namespace RuntimeEnvironment {
+  let stopping: boolean;
+  type Type = 'node' | 'deno' | 'bun';
+  function get(): Type | null;
+  function sleep(time: number): Promise<void>;
+  function handleExitSignal(client: Client, signal: NodeJS.Signals): Promise<void>;
+}
+//#endregion
+export { RuntimeEnvironment };
+//# sourceMappingURL=RuntimeEnvironment.d.mts.map

package/dist/classes/cli/RuntimeEnvironment.mjs

@@ -0,0 +1,36 @@
+import { colors } from "@reciple/utils";
+import { setTimeout } from "node:timers/promises";
+
+//#region src/classes/cli/RuntimeEnvironment.ts
+var RuntimeEnvironment = class {};
+(function(_RuntimeEnvironment) {
+	let stopping = _RuntimeEnvironment.stopping = false;
+	function get() {
+		if ("isBun" in process && process.isBun) return "bun";
+		if ("deno" in process.versions && process.versions.deno) return "deno";
+		if (process.versions.node) return "node";
+		return null;
+	}
+	_RuntimeEnvironment.get = get;
+	async function sleep(time) {
+		return setTimeout(time);
+	}
+	_RuntimeEnvironment.sleep = sleep;
+	async function handleExitSignal(client, signal) {
+		if (stopping) return;
+		stopping = true;
+		client.logger?.warn(`Received exit signal: ${signal}`);
+		await client.destroy();
+		client.eventListeners.unregisterAll();
+		const signalString = signal === "SIGINT" ? "keyboard interrupt" : signal === "SIGTERM" ? "terminate" : String(signal);
+		await sleep(10);
+		client.logger?.warn(`Process exited: ${colors.yellow(signalString)}`);
+		client.logger?.closeFileWriteStream();
+		process.exit(0);
+	}
+	_RuntimeEnvironment.handleExitSignal = handleExitSignal;
+})(RuntimeEnvironment || (RuntimeEnvironment = {}));
+
+//#endregion
+export { RuntimeEnvironment };
+//# sourceMappingURL=RuntimeEnvironment.mjs.map

package/dist/classes/cli/RuntimeEnvironment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeEnvironment.mjs","names":[],"sources":["../../../src/classes/cli/RuntimeEnvironment.ts"],"sourcesContent":["import { colors } from '@reciple/utils';\nimport type { Client } from '@reciple/core';\nimport { setTimeout } from 'node:timers/promises';\n\nexport class RuntimeEnvironment {}\n\nexport namespace RuntimeEnvironment {\n    export let stopping = false;\n\n    export type Type = 'node'|'deno'|'bun';\n\n    export function get(): Type|null {\n        if ('isBun' in process && process.isBun) return 'bun';\n        if ('deno' in process.versions && process.versions.deno) return 'deno';\n        if (process.versions.node) return 'node';\n\n        return null;\n    }\n\n    export async function sleep(time: number): Promise<void> {\n        return setTimeout(time);\n    }\n\n    export async function handleExitSignal(client: Client, signal: NodeJS.Signals) {\n        if (stopping) return;\n\n        stopping = true;\n\n        client.logger?.warn(`Received exit signal: ${signal}`);\n\n        await client.destroy();\n        client.eventListeners.unregisterAll();\n\n        const signalString = signal === 'SIGINT' ? 'keyboard interrupt' : signal === 'SIGTERM' ? 'terminate' : String(signal);\n\n        await sleep(10);\n\n        client.logger?.warn(`Process exited: ${colors.yellow(signalString)}`);\n        client.logger?.closeFileWriteStream();\n        process.exit(0);\n    }\n}\n"],"mappings":";;;;AAIA,IAAa,qBAAb,MAAgC;;CAGrB,IAAI,0CAAW;CAIf,SAAS,MAAiB;AAC7B,MAAI,WAAW,WAAW,QAAQ,MAAO,QAAO;AAChD,MAAI,UAAU,QAAQ,YAAY,QAAQ,SAAS,KAAM,QAAO;AAChE,MAAI,QAAQ,SAAS,KAAM,QAAO;AAElC,SAAO;;;CAGJ,eAAe,MAAM,MAA6B;AACrD,SAAO,WAAW,KAAK;;;CAGpB,eAAe,iBAAiB,QAAgB,QAAwB;AAC3E,MAAI,SAAU;AAEd,aAAW;AAEX,SAAO,QAAQ,KAAK,yBAAyB,SAAS;AAEtD,QAAM,OAAO,SAAS;AACtB,SAAO,eAAe,eAAe;EAErC,MAAM,eAAe,WAAW,WAAW,uBAAuB,WAAW,YAAY,cAAc,OAAO,OAAO;AAErH,QAAM,MAAM,GAAG;AAEf,SAAO,QAAQ,KAAK,mBAAmB,OAAO,OAAO,aAAa,GAAG;AACrE,SAAO,QAAQ,sBAAsB;AACrC,UAAQ,KAAK,EAAE"}

package/dist/classes/client/EventListeners.d.mts

@@ -0,0 +1,26 @@
+import { Client } from "@reciple/core";
+import { EventEmitter } from "node:events";
+
+//#region src/classes/client/EventListeners.d.ts
+declare class EventListeners {
+  registeredEvents: EventListeners.RegisteredEvent[];
+  register(event: EventListeners.RegisteredEvent): this;
+  unregister(event: EventListeners.RegisteredEvent): this;
+  unregisterAll(): this;
+  registerProcessExitEvents(listener: (signal: NodeJS.Signals) => any): this;
+  unregisterProcessExitEvents(listener: (signal: NodeJS.Signals) => any): this;
+}
+declare namespace EventListeners {
+  const processExitEvents: string[];
+  interface RegisteredEvent {
+    event: string | symbol;
+    emitter: EventEmitter;
+    once?: boolean;
+    onEvent: (...args: any) => any;
+  }
+  function registerLoggerEventListeners(client: Client): void;
+  function registerCommandsEventListeners(client: Client): void;
+}
+//#endregion
+export { EventListeners };
+//# sourceMappingURL=EventListeners.d.mts.map

package/dist/classes/client/EventListeners.mjs

@@ -0,0 +1,103 @@
+import { BaseModule } from "../modules/BaseModule.mjs";
+import { Format, colors } from "@reciple/utils";
+import { CommandType } from "@reciple/core";
+
+//#region src/classes/client/EventListeners.ts
+var EventListeners = class EventListeners {
+	registeredEvents = [];
+	register(event) {
+		event.onEvent = event.onEvent.bind(event);
+		if (event.once) event.emitter.once(event.event, event.onEvent);
+		else event.emitter.on(event.event, event.onEvent);
+		this.registeredEvents.push(event);
+		return this;
+	}
+	unregister(event) {
+		event.emitter.removeListener(event.event, event.onEvent);
+		this.registeredEvents = this.registeredEvents.filter((e) => e !== event);
+		return this;
+	}
+	unregisterAll() {
+		this.registeredEvents.forEach((event) => this.unregister(event));
+		this.registeredEvents = [];
+		return this;
+	}
+	registerProcessExitEvents(listener) {
+		for (const event of EventListeners.processExitEvents) this.register({
+			emitter: process,
+			event,
+			onEvent: listener
+		});
+		return this;
+	}
+	unregisterProcessExitEvents(listener) {
+		for (const event of EventListeners.processExitEvents) this.unregister({
+			emitter: process,
+			event,
+			onEvent: listener
+		});
+		return this;
+	}
+};
+(function(_EventListeners) {
+	_EventListeners.processExitEvents = [
+		"SIGHUP",
+		"SIGINT",
+		"SIGQUIT",
+		"SIGABRT",
+		"SIGALRM",
+		"SIGTERM",
+		"SIGBREAK",
+		"SIGUSR2"
+	];
+	function registerLoggerEventListeners(client) {
+		const defineModuleManagerEvent = (event, onEvent) => ({
+			emitter: client.modules,
+			event,
+			onEvent
+		});
+		const defineModuleLoaderEvent = (event, onEvent) => ({
+			emitter: client.moduleLoader,
+			event,
+			onEvent
+		});
+		const defineClientEvent = (event, onEvent) => ({
+			emitter: client,
+			event,
+			onEvent
+		});
+		const events = [
+			defineModuleManagerEvent("modulePreEnable", (module) => client.logger.log(`Enabling module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleManagerEvent("moduleEnable", (module) => client.logger.log(`Enabled module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleManagerEvent("modulePreReady", (module) => client.logger.log(`Preparing module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleManagerEvent("moduleReady", (module) => client.logger.log(`Ready module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleManagerEvent("modulePreDisable", (module) => client.logger.log(`Disabling module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleManagerEvent("moduleDisable", (module) => client.logger.log(`Disabled module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleManagerEvent("moduleEnableError", (module, error) => client.logger.error(`Failed to enable module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}:`, error)),
+			defineModuleManagerEvent("moduleReadyError", (module, error) => client.logger.error(`Failed to ready module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}:`, error)),
+			defineModuleManagerEvent("moduleDisableError", (module, error) => client.logger.error(`Failed to disable module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}:`, error)),
+			defineModuleLoaderEvent("modulesResolving", () => client.logger.log(colors.green("🔍 Resolving modules..."))),
+			defineModuleLoaderEvent("modulesResolved", (modules) => client.logger.log(colors.green(`✅ Resolved ${modules.length} ${Format.plural(modules.length, "module")}.`))),
+			defineModuleLoaderEvent("moduleResolving", (filepath) => client.logger.debug(`Resolving module ${colors.cyan(`"${filepath}"`)}`)),
+			defineModuleLoaderEvent("moduleResolved", (module) => client.logger.debug(`Resolved module ${colors.cyan(`"${BaseModule.getFilepath(module) || module.id}"`)}`)),
+			defineModuleLoaderEvent("moduleResolveError", (error) => client.logger.error(`Failed to resolve module:`, error)),
+			defineClientEvent("debug", (message) => client.logger.debug(message))
+		];
+		for (const event of events) client.eventListeners.register(event);
+	}
+	_EventListeners.registerLoggerEventListeners = registerLoggerEventListeners;
+	function registerCommandsEventListeners(client) {
+		const defineCommandsEvent = (event, onEvent) => ({
+			emitter: client.commands,
+			event,
+			onEvent
+		});
+		const events = [defineCommandsEvent("applicationCommandsRegister", (commands, guildId) => client.logger.log(colors.green(`📩 Registered ${colors.cyan(commands.size)} application ${Format.plural(commands.size, "command")}${guildId ? ` to guild ${colors.magenta(guildId)}` : colors.magenta(" globally")}.`))), defineCommandsEvent("commandExecute", (data) => client.logger.debug(`Executed ${CommandType[data.command.type].toLowerCase()} command ${colors.cyan(`"${data.command.data.name}"`)} ${colors.magenta(`(${data.command.id})`)}`))];
+		for (const event of events) client.eventListeners.register(event);
+	}
+	_EventListeners.registerCommandsEventListeners = registerCommandsEventListeners;
+})(EventListeners || (EventListeners = {}));
+
+//#endregion
+export { EventListeners };
+//# sourceMappingURL=EventListeners.mjs.map

package/dist/classes/client/EventListeners.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventListeners.mjs","names":["events: RegisteredEvent[]"],"sources":["../../../src/classes/client/EventListeners.ts"],"sourcesContent":["import { CommandType, type Client, type CommandManager } from '@reciple/core';\nimport type { EventEmitter } from 'node:events';\nimport type { ModuleManager } from '../managers/ModuleManager.js';\nimport { BaseModule } from '../modules/BaseModule.js';\nimport { colors, Format } from '@reciple/utils';\nimport type { ModuleLoader } from './ModuleLoader.js';\n\nexport class EventListeners {\n    public registeredEvents: EventListeners.RegisteredEvent[] = [];\n\n    public register(event: EventListeners.RegisteredEvent): this {\n        event.onEvent = event.onEvent.bind(event);\n\n        if (event.once) {\n            event.emitter.once(event.event, event.onEvent);\n        } else {\n            event.emitter.on(event.event, event.onEvent);\n        }\n\n        this.registeredEvents.push(event);\n        return this;\n    }\n\n    public unregister(event: EventListeners.RegisteredEvent): this {\n        event.emitter.removeListener(event.event, event.onEvent);\n        this.registeredEvents = this.registeredEvents.filter(e => e !== event);\n        return this;\n    }\n\n    public unregisterAll(): this {\n        this.registeredEvents.forEach(event => this.unregister(event));\n        this.registeredEvents = [];\n        return this;\n    }\n\n    public registerProcessExitEvents(listener: (signal: NodeJS.Signals) => any): this {\n        for (const event of EventListeners.processExitEvents) {\n            this.register({ emitter: process, event, onEvent: listener });\n        }\n\n        return this;\n    }\n\n    public unregisterProcessExitEvents(listener: (signal: NodeJS.Signals) => any): this {\n        for (const event of EventListeners.processExitEvents) {\n            this.unregister({ emitter: process, event, onEvent: listener });\n        }\n\n        return this;\n    }\n}\n\nexport namespace EventListeners {\n    export const processExitEvents = [\n        'SIGHUP',\n        'SIGINT',\n        'SIGQUIT',\n        'SIGABRT',\n        'SIGALRM',\n        'SIGTERM',\n        'SIGBREAK',\n        'SIGUSR2',\n    ];\n\n    export interface RegisteredEvent {\n        event: string|symbol;\n        emitter: EventEmitter;\n        once?: boolean;\n        onEvent: (...args: any) => any;\n    }\n\n    export function registerLoggerEventListeners(client: Client) {\n        const defineModuleManagerEvent = <E extends keyof ModuleManager.Events>(event: E, onEvent: (...args: ModuleManager.Events[E]) => any): RegisteredEvent => ({ emitter: client.modules, event, onEvent });\n        const defineModuleLoaderEvent = <E extends keyof ModuleLoader.Events>(event: E, onEvent: (...args: ModuleLoader.Events[E]) => any): RegisteredEvent => ({ emitter: client.moduleLoader, event, onEvent });\n        const defineClientEvent = <E extends keyof Client.Events>(event: E, onEvent: (...args: Client.Events[E]) => any): RegisteredEvent => ({ emitter: client, event, onEvent });\n\n        const events: RegisteredEvent[] = [\n            defineModuleManagerEvent('modulePreEnable', (module) => client.logger.log(`Enabling module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleManagerEvent('moduleEnable', (module) => client.logger.log(`Enabled module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleManagerEvent('modulePreReady', (module) => client.logger.log(`Preparing module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleManagerEvent('moduleReady', (module) => client.logger.log(`Ready module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleManagerEvent('modulePreDisable', (module) => client.logger.log(`Disabling module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleManagerEvent('moduleDisable', (module) => client.logger.log(`Disabled module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleManagerEvent('moduleEnableError', (module, error) => client.logger.error(`Failed to enable module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}:`, error)),\n            defineModuleManagerEvent('moduleReadyError', (module, error) => client.logger.error(`Failed to ready module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}:`, error)),\n            defineModuleManagerEvent('moduleDisableError', (module, error) => client.logger.error(`Failed to disable module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}:`, error)),\n            defineModuleLoaderEvent('modulesResolving', () => client.logger.log(colors.green('🔍 Resolving modules...'))),\n            defineModuleLoaderEvent('modulesResolved', (modules) => client.logger.log(colors.green(`✅ Resolved ${modules.length} ${Format.plural(modules.length, 'module')}.`))),\n            defineModuleLoaderEvent('moduleResolving', (filepath) => client.logger.debug(`Resolving module ${colors.cyan(`\"${filepath}\"`)}`)),\n            defineModuleLoaderEvent('moduleResolved', (module) => client.logger.debug(`Resolved module ${colors.cyan(`\"${BaseModule.getFilepath(module) || module.id}\"`)}`)),\n            defineModuleLoaderEvent('moduleResolveError', (error) => client.logger.error(`Failed to resolve module:`, error)),\n            defineClientEvent('debug', (message) => client.logger.debug(message)),\n        ];\n\n        for (const event of events) {\n            client.eventListeners.register(event);\n        }\n    }\n\n    export function registerCommandsEventListeners(client: Client) {\n        const defineCommandsEvent = <E extends keyof CommandManager.Events>(event: E, onEvent: (...args: CommandManager.Events[E]) => any): RegisteredEvent => ({ emitter: client.commands!, event, onEvent });\n\n        const events: RegisteredEvent[] = [\n            defineCommandsEvent('applicationCommandsRegister', (commands, guildId) => client.logger.log(colors.green(`📩 Registered ${colors.cyan(commands.size)} application ${Format.plural(commands.size, 'command')}${guildId ? ` to guild ${colors.magenta(guildId)}` : colors.magenta(' globally')}.`))),\n            defineCommandsEvent('commandExecute', (data) => client.logger.debug(`Executed ${CommandType[data.command.type].toLowerCase()} command ${colors.cyan(`\"${data.command.data.name}\"`)} ${colors.magenta(`(${data.command.id})`)}`)),\n        ];\n\n        for (const event of events) {\n            client.eventListeners.register(event);\n        }\n    }\n}\n"],"mappings":"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"}

package/dist/classes/client/ModuleLoader.d.mts

@@ -0,0 +1,55 @@
+import { AnyModule } from "../../helpers/types.mjs";
+import { Logger } from "prtyprnt";
+import { Client, RecipleError } from "@reciple/core";
+import { Awaitable } from "discord.js";
+import * as globby0 from "globby";
+import { EventEmitter } from "node:events";
+
+//#region src/classes/client/ModuleLoader.d.ts
+declare class ModuleLoader extends EventEmitter<ModuleLoader.Events> {
+  readonly client: Client;
+  readonly logger: Logger;
+  constructor(client: Client);
+  findModules(ignoreErrors?: boolean): Promise<AnyModule[]>;
+  static scanForDirectories(config?: Pick<ModuleLoader.Config, 'directories' | 'ignore'> & {
+    cwd?: string;
+    createDirectories?: boolean;
+  }): Promise<string[]>;
+  static scanForModules(config?: ModuleLoader.Config & {
+    cwd?: string;
+    createDirectories?: boolean;
+  }): Promise<string[]>;
+  static resolveModulePath(filepath: string, options?: {
+    cwd?: string;
+  }): Promise<AnyModule>;
+  static resolveSourceDirectories(options: ModuleLoader.ResolveSourceDirectoryOptions): Promise<string[]>;
+  private emitOrThrow;
+}
+declare namespace ModuleLoader {
+  let globby: typeof globby0 | null;
+  const fileTypes: string[];
+  interface Config {
+    directories?: string[];
+    ignore?: string[];
+    filter?: (filepath: string) => Awaitable<boolean>;
+    sort?: (a: string, b: string) => number;
+  }
+  interface Events {
+    moduleResolveError: [error: RecipleError];
+    moduleResolved: [module: AnyModule];
+    moduleResolving: [filepath: string];
+    modulesResolved: [modules: AnyModule[]];
+    modulesResolving: [files: string[]];
+  }
+  interface ResolveSourceDirectoryOptions {
+    directories: string[];
+    baseUrl: string;
+    rootDir: string;
+    outDir: string;
+    cwd?: string;
+  }
+  function getGlobby(): Promise<typeof globby0>;
+}
+//#endregion
+export { ModuleLoader };
+//# sourceMappingURL=ModuleLoader.d.mts.map

package/dist/classes/client/ModuleLoader.mjs

@@ -0,0 +1,152 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { BaseModule } from "../modules/BaseModule.mjs";
+import { BaseModuleValidator } from "../validation/BaseModuleValidator.mjs";
+import { PostconditionModule } from "../modules/PostconditionModule.mjs";
+import { PreconditionModule } from "../modules/PreconditionModule.mjs";
+import { EventModule } from "../modules/events/EventModule.mjs";
+import { MessageCommandModule } from "../modules/commands/MessageCommandModule.mjs";
+import { SlashCommandModule } from "../modules/commands/SlashCommandModule.mjs";
+import { ContextMenuCommandModule } from "../modules/commands/ContextMenuCommandModule.mjs";
+import { CommandModuleValidator } from "../validation/CommandModuleValidator.mjs";
+import { EventModuleValidator } from "../validation/EventModuleValidator.mjs";
+import { PreconditionModuleValidator } from "../validation/PreconditionModule.mjs";
+import { PostconditionModuleValidator } from "../validation/PostconditionModule.mjs";
+import path from "node:path";
+import { colors, recursiveDefaults } from "@reciple/utils";
+import { mkdir, readdir, stat } from "node:fs/promises";
+import { CommandType, RecipleError } from "@reciple/core";
+import "discord.js";
+import micromatch from "micromatch";
+import { globby, isDynamicPattern } from "globby";
+import { EventEmitter } from "node:events";
+
+//#region src/classes/client/ModuleLoader.ts
+var ModuleLoader = class ModuleLoader extends EventEmitter {
+	logger;
+	constructor(client) {
+		super();
+		this.client = client;
+		this.logger = this.client.logger.clone({ label: "ModuleLoader" });
+	}
+	async findModules(ignoreErrors = false) {
+		const modulePaths = await ModuleLoader.scanForModules(this.client.config?.modules);
+		const modules = [];
+		this.emit("modulesResolving", modulePaths);
+		for (const path$1 of modulePaths) try {
+			this.emit("moduleResolving", path$1);
+			const resolved = await ModuleLoader.resolveModulePath(path$1);
+			Object.assign(resolved, {
+				client: this.client,
+				__$filepath: path$1
+			});
+			modules.push(resolved);
+			this.emit("moduleResolved", resolved);
+		} catch (error) {
+			if (ignoreErrors) continue;
+			this.emitOrThrow("moduleResolveError", new RecipleError({
+				message: `Failed to load module: ${colors.cyan(path$1)}`,
+				cause: error
+			}));
+		}
+		this.emit("modulesResolved", modules);
+		return modules;
+	}
+	static async scanForDirectories(config) {
+		const cwd = config?.cwd ?? process.cwd();
+		let scanned = [];
+		let directories = [];
+		for (const directory of config?.directories ?? []) {
+			if (isDynamicPattern(directory, { cwd })) {
+				const matches = await globby(directory, {
+					cwd,
+					ignore: config?.ignore,
+					onlyDirectories: true,
+					baseNameMatch: true,
+					absolute: true
+				});
+				scanned.push(...matches);
+				continue;
+			}
+			scanned.push(path.join(cwd, directory));
+		}
+		for (const directory of scanned) {
+			if (!await stat(directory).catch(() => void 0) && config?.createDirectories !== false) await mkdir(directory, { recursive: true });
+			directories.push(directory);
+		}
+		return directories;
+	}
+	static async scanForModules(config) {
+		const directories = await ModuleLoader.scanForDirectories(config);
+		let modules = [];
+		for (const directory of directories) {
+			let files = await readdir(directory);
+			if (config?.ignore?.length) files = micromatch.not(files, config.ignore, {
+				cwd: directory,
+				matchBase: true,
+				dot: true
+			});
+			files = files.map((f) => path.join(directory, f));
+			for (const file of files) {
+				if (config?.filter ? !await config?.filter(file) : ModuleLoader.fileTypes.every((type) => !file.endsWith(`.${type}`))) continue;
+				modules.push(file);
+			}
+		}
+		if (config?.sort) modules.sort(config.sort);
+		return modules;
+	}
+	static async resolveModulePath(filepath, options) {
+		if (!await stat(filepath).catch(() => void 0)) throw new RecipleError(`Module not found: ${filepath}`);
+		const data = recursiveDefaults(await import(`file://${path.resolve(options?.cwd ?? process.cwd(), filepath)}`));
+		if (BaseModule.isModule(data)) return data;
+		switch (data?.moduleType) {
+			case ModuleType.Command:
+				CommandModuleValidator.isValid(data);
+				switch (data.type) {
+					case CommandType.Message: return MessageCommandModule.from(data);
+					case CommandType.Slash: return SlashCommandModule.from(data);
+					case CommandType.ContextMenu: return ContextMenuCommandModule.from(data);
+					default: throw new RecipleError(`Unknown command type from module: ${colors.cyan(filepath)}`);
+				}
+			case ModuleType.Event:
+				EventModuleValidator.isValid(data);
+				return EventModule.from(data);
+			case ModuleType.Precondition:
+				PreconditionModuleValidator.isValid(data);
+				return PreconditionModule.from(data);
+			case ModuleType.Postcondition:
+				PostconditionModuleValidator.isValid(data);
+				return PostconditionModule.from(data);
+			case ModuleType.Base:
+			default:
+				BaseModuleValidator.isValid(data);
+				return BaseModule.from(data);
+		}
+	}
+	static async resolveSourceDirectories(options) {
+		const dir = path.isAbsolute(options.baseUrl) ? options.baseUrl : path.resolve(path.join(options.cwd ?? process.cwd(), options.baseUrl));
+		const root = path.resolve(path.join(dir, options.rootDir));
+		const out = path.resolve(path.join(dir, options.outDir));
+		return options.directories.map((directory) => path.resolve(directory).replace(out, root));
+	}
+	emitOrThrow(event, error) {
+		if (this.client.listenerCount(event) > 0) return this.emit(event, error);
+		throw error;
+	}
+};
+(function(_ModuleLoader) {
+	let globby$1 = _ModuleLoader.globby = null;
+	_ModuleLoader.fileTypes = [
+		"js",
+		"mjs",
+		"jsx"
+	];
+	async function getGlobby() {
+		if (globby$1) return globby$1;
+		return globby$1 = await import("globby");
+	}
+	_ModuleLoader.getGlobby = getGlobby;
+})(ModuleLoader || (ModuleLoader = {}));
+
+//#endregion
+export { ModuleLoader };
+//# sourceMappingURL=ModuleLoader.mjs.map