@reciple/modules 10.0.1

package/README.md

@@ -0,0 +1,160 @@
+<div align="center">
+    <img src="https://i.imgur.com/C3gWxwc.png" width="50%">
+    <p align="center">
+        <b>A Discord.js framework that just works.</b>
+    </p>
+    <br>
+</div>
+
+<h3 align="center">
+    <a href="https://discord.gg/KxfPZYuTGV">
+        <img src="https://img.shields.io/discord/1453743492722458708?color=5865F2&logo=discord&logoColor=white">
+    </a>
+    <a href="https://npmjs.org/package/@reciple/modules">
+        <img src="https://img.shields.io/npm/v/@reciple/modules?label=npm">
+    </a>
+    <a href="https://github.com/reciplejs/reciple/tree/main/packages/modules">
+        <img src="https://img.shields.io/npm/dt/@reciple/modules?maxAge=3600">
+    </a>
+    <a href="https://www.codefactor.io/repository/github/reciplejs/reciple">
+        <img src="https://www.codefactor.io/repository/github/reciplejs/reciple/badge">
+    </a>
+    <br>
+    <div style="padding-top: 1rem">
+        <a href="https://discord.gg/KxfPZYuTGV">
+            <img src="http://invidget.switchblade.xyz/KxfPZYuTGV">
+        </a>
+    </div>
+</h3>
+
+## About
+
+`@reciple/modules` A JSX wrapper for [Discord.js](https://discord.js.org/) builders.
+
+## Installation
+
+```bash
+npm install @reciple/modules
+yarn add @reciple/modules
+pnpm add @reciple/modules
+bun install @reciple/modules
+deno install npm:@reciple/modules
+```
+
+## Usage
+
+Create a new reciple module file then create a new module instance as the default export.
+
+### Anticrash
+
+A module that catches process and client errors that cause the bot to crash then logs them to a channel if specified.
+
+```js
+// example/src/addons/antiCrash.js
+import { RecipleAnticrash } from '@reciple/modules';
+
+export default new RecipleAnticrash({
+    // The channels to report errors to
+    reportChannels: ['000000000000000000'],
+
+    // The base options for the report message
+    baseReportMessageOptions: {
+        content: 'An error has occurred!',
+    }
+});
+```
+
+### Registry Cache
+
+A module that caches the application commands to prevent unnecessary requests to the Discord API when registering commands that haven't changed.
+
+```js
+// example/src/addons/registryCache.js
+import { RecipleRegistryCache } from '@reciple/modules';
+
+export default new RecipleRegistryCache({
+    // Cache duration in milliseconds
+    maxCacheAgeMs: 24 * 60 * 60 * 1000,
+
+    // The directory to store the cache in
+    cacheDir: '.cache/reciple-registry/',
+
+    // The environment variable to check if the cache is enabled
+    cacheEnabledEnv: 'RECIPLE_REGISTRY_CACHE',
+
+    // Create a cache entry even if the cache is disabled
+    createCacheEntryEvenIfDisabled: true
+});
+```
+
+### Interaction Events
+
+A module that handles interaction events and executes listeners based on the interaction type. The listeners are resolved from the specified module property.
+
+```js
+// example/src/addons/interactionEvents.js
+import { RecipleInteractionEvents } from '@reciple/modules';
+
+export default new RecipleInteractionEvents({
+    // Filters the modules to resolve listeners from
+    ignoredModules: (module) => module.id === 'ignored_id',
+
+    // The module property to resolve listeners from
+    moduleEventListenersProperty: ['interactions']
+});
+```
+
+```js
+// example/src/commands/ping.js
+import { InteractionListenerBuilder, InteractionListenerType } from '@reciple/modules';
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
+import { SlashCommandBuilder, SlashCommandModule, type SlashCommand } from 'reciple';
+
+export class ButtonPingCommand extends SlashCommandModule {
+    data = new SlashCommandBuilder()
+        .setName('ping')
+        .setDescription('Test ping command')
+        .toJSON();
+
+    /**
+     * @type {InteractionListenerBuilder[]}
+     */
+    interactions = [
+        new InteractionListenerBuilder()
+            .setType(InteractionListenerType.Button)
+            .setFilter(interaction => interaction.customId === 'ping')
+            .setExecute(async interaction => {
+                await interaction.reply({
+                    content: 'Pong!',
+                    ephemeral: true
+                });
+            })
+    ];
+
+    /**
+     * @param {SlashCommand.ExecuteData} data
+     */
+    async execute(data) {
+        await data.interaction.reply({
+            components: [
+                new ActionRowBuilder()
+                    .addComponents(
+                        new ButtonBuilder()
+                            .setCustomId('ping')
+                            .setLabel('Ping')
+                            .setStyle(ButtonStyle.Primary)
+                    )
+            ]
+        });
+    }
+}
+
+export default new ButtonPingCommand();
+```
+
+## Links
+
+- [Website](https://reciple.js.org)
+- [Discord](https://discord.gg/KxfPZYuTGV)
+- [Github](https://github.com/reciplejs/reciple/tree/main/packages/modules)
+- [NPM](https://npmjs.org/package/@reciple/modules)

package/dist/classes/InteractionListener.d.mts

@@ -0,0 +1,22 @@
+import { InteractionListenerType } from "../helpers/constants.mjs";
+import { InteractionFromListenerType, InteractionListenerData } from "../helpers/types.mjs";
+import { JSONEncodable } from "discord.js";
+
+//#region src/classes/InteractionListener.d.ts
+declare class InteractionListener<T extends InteractionListenerType> implements InteractionListenerData<T> {
+  readonly id: string;
+  readonly moduleId?: string;
+  readonly type: T;
+  readonly once?: boolean;
+  constructor(data: InteractionListener.Resolvable<T>);
+  filter(interaction: InteractionFromListenerType<T>): boolean;
+  execute(interaction: InteractionFromListenerType<T>): Promise<void>;
+  toJSON(): InteractionListenerData<T>;
+  static from<T extends InteractionListenerType>(data: InteractionListener.Resolvable<T>): InteractionListener<T>;
+}
+declare namespace InteractionListener {
+  type Resolvable<T extends InteractionListenerType> = InteractionListener<T> | InteractionListenerData<T> | JSONEncodable<InteractionListenerData<T>>;
+}
+//#endregion
+export { InteractionListener };
+//# sourceMappingURL=InteractionListener.d.mts.map

package/dist/classes/InteractionListener.mjs

@@ -0,0 +1,34 @@
+import { isJSONEncodable } from "discord.js";
+import { DiscordSnowflake } from "@sapphire/snowflake";
+
+//#region src/classes/InteractionListener.ts
+var InteractionListener = class InteractionListener {
+	id = DiscordSnowflake.generate().toString();
+	moduleId;
+	type;
+	once;
+	constructor(data) {
+		Object.assign(this, isJSONEncodable(data) ? data.toJSON() : data);
+	}
+	filter(interaction) {
+		return true;
+	}
+	execute(interaction) {
+		return Promise.resolve();
+	}
+	toJSON() {
+		return {
+			type: this.type,
+			once: this.once,
+			filter: this.filter,
+			execute: this.execute
+		};
+	}
+	static from(data) {
+		return data instanceof InteractionListener ? data : new InteractionListener(data);
+	}
+};
+
+//#endregion
+export { InteractionListener };
+//# sourceMappingURL=InteractionListener.mjs.map

package/dist/classes/InteractionListener.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionListener.mjs","names":[],"sources":["../../src/classes/InteractionListener.ts"],"sourcesContent":["import { isJSONEncodable, type JSONEncodable } from 'discord.js';\nimport type { InteractionListenerType } from '../helpers/constants.js';\nimport type { InteractionListenerData, InteractionFromListenerType } from '../helpers/types.js';\nimport { DiscordSnowflake } from '@sapphire/snowflake';\n\nexport class InteractionListener<T extends InteractionListenerType> implements InteractionListenerData<T> {\n    public readonly id: string = DiscordSnowflake.generate().toString();\n    public readonly moduleId?: string;\n    public readonly type!: T;\n    public readonly once?: boolean;\n\n    constructor(data: InteractionListener.Resolvable<T>) {\n        Object.assign(this, isJSONEncodable(data) ? data.toJSON() : data);\n    }\n\n    public filter(interaction: InteractionFromListenerType<T>): boolean {\n        return true;\n    }\n\n    public execute(interaction: InteractionFromListenerType<T>): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public toJSON(): InteractionListenerData<T> {\n        return {\n            type: this.type,\n            once: this.once,\n            filter: this.filter,\n            execute: this.execute\n        };\n    }\n\n    public static from<T extends InteractionListenerType>(data: InteractionListener.Resolvable<T>): InteractionListener<T> {\n        return data instanceof InteractionListener ? data : new InteractionListener(data);\n    }\n}\n\nexport namespace InteractionListener {\n    export type Resolvable<T extends InteractionListenerType> = InteractionListener<T>|InteractionListenerData<T>|JSONEncodable<InteractionListenerData<T>>;\n}\n"],"mappings":";;;;AAKA,IAAa,sBAAb,MAAa,oBAA6F;CACtG,AAAgB,KAAa,iBAAiB,UAAU,CAAC,UAAU;CACnE,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,YAAY,MAAyC;AACjD,SAAO,OAAO,MAAM,gBAAgB,KAAK,GAAG,KAAK,QAAQ,GAAG,KAAK;;CAGrE,AAAO,OAAO,aAAsD;AAChE,SAAO;;CAGX,AAAO,QAAQ,aAA4D;AACvE,SAAO,QAAQ,SAAS;;CAG5B,AAAO,SAAqC;AACxC,SAAO;GACH,MAAM,KAAK;GACX,MAAM,KAAK;GACX,QAAQ,KAAK;GACb,SAAS,KAAK;GACjB;;CAGL,OAAc,KAAwC,MAAiE;AACnH,SAAO,gBAAgB,sBAAsB,OAAO,IAAI,oBAAoB,KAAK"}

package/dist/classes/builders/InteractionListenerBuilder.d.mts

@@ -0,0 +1,16 @@
+import { InteractionListenerType } from "../../helpers/constants.mjs";
+import { InteractionListenerData } from "../../helpers/types.mjs";
+
+//#region src/classes/builders/InteractionListenerBuilder.d.ts
+declare class InteractionListenerBuilder<T extends InteractionListenerType> {
+  readonly data: Partial<InteractionListenerData<T>>;
+  constructor(data?: Partial<InteractionListenerData<T>>);
+  setType<Type extends T>(type: Type): InteractionListenerBuilder<Type>;
+  setOnce(once: boolean): this;
+  setFilter(filter: InteractionListenerData<T>['filter']): this;
+  setExecute(execute: InteractionListenerData<T>['execute']): this;
+  toJSON(): InteractionListenerData<T>;
+}
+//#endregion
+export { InteractionListenerBuilder };
+//# sourceMappingURL=InteractionListenerBuilder.d.mts.map

package/dist/classes/builders/InteractionListenerBuilder.mjs

@@ -0,0 +1,30 @@
+//#region src/classes/builders/InteractionListenerBuilder.ts
+var InteractionListenerBuilder = class {
+	data = {};
+	constructor(data) {
+		if (data) this.data = data;
+	}
+	setType(type) {
+		this.data.type = type;
+		return this;
+	}
+	setOnce(once) {
+		this.data.once = once;
+		return this;
+	}
+	setFilter(filter) {
+		this.data.filter = filter;
+		return this;
+	}
+	setExecute(execute) {
+		this.data.execute = execute;
+		return this;
+	}
+	toJSON() {
+		return this.data;
+	}
+};
+
+//#endregion
+export { InteractionListenerBuilder };
+//# sourceMappingURL=InteractionListenerBuilder.mjs.map

package/dist/classes/builders/InteractionListenerBuilder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionListenerBuilder.mjs","names":[],"sources":["../../../src/classes/builders/InteractionListenerBuilder.ts"],"sourcesContent":["import { InteractionListenerType } from '../../helpers/constants.js';\nimport type { InteractionListenerData } from '../../helpers/types.js';\n\nexport class InteractionListenerBuilder<T extends InteractionListenerType> {\n    public readonly data: Partial<InteractionListenerData<T>> = {};\n\n    public constructor(data?: Partial<InteractionListenerData<T>>) {\n        if (data) this.data = data;\n    }\n\n    public setType<Type extends T>(type: Type): InteractionListenerBuilder<Type> {\n        this.data.type = type;\n        return this as any;\n    }\n\n    public setOnce(once: boolean): this {\n        this.data.once = once;\n        return this;\n    }\n\n    public setFilter(filter: InteractionListenerData<T>['filter']): this {\n        this.data.filter = filter;\n        return this;\n    }\n\n    public setExecute(execute: InteractionListenerData<T>['execute']): this {\n        this.data.execute = execute;\n        return this;\n    }\n\n    public toJSON(): InteractionListenerData<T> {\n        return this.data as InteractionListenerData<T>;\n    }\n}\n"],"mappings":";AAGA,IAAa,6BAAb,MAA2E;CACvE,AAAgB,OAA4C,EAAE;CAE9D,AAAO,YAAY,MAA4C;AAC3D,MAAI,KAAM,MAAK,OAAO;;CAG1B,AAAO,QAAwB,MAA8C;AACzE,OAAK,KAAK,OAAO;AACjB,SAAO;;CAGX,AAAO,QAAQ,MAAqB;AAChC,OAAK,KAAK,OAAO;AACjB,SAAO;;CAGX,AAAO,UAAU,QAAoD;AACjE,OAAK,KAAK,SAAS;AACnB,SAAO;;CAGX,AAAO,WAAW,SAAsD;AACpE,OAAK,KAAK,UAAU;AACpB,SAAO;;CAGX,AAAO,SAAqC;AACxC,SAAO,KAAK"}

package/dist/classes/modules/RecipleAnticrash.d.mts

@@ -0,0 +1,38 @@
+import { Awaitable, BaseMessageOptions as BaseMessageOptions$1, Message, SendableChannels } from "discord.js";
+import { BaseModule } from "reciple";
+
+//#region src/classes/modules/RecipleAnticrash.d.ts
+declare class RecipleAnticrash extends BaseModule implements RecipleAnticrash.Options {
+  readonly id: string;
+  baseReportMessageOptions?: RecipleAnticrash.Options['baseReportMessageOptions'];
+  reportChannels: string[];
+  private readonly logger;
+  constructor(options?: RecipleAnticrash.Options);
+  onEnable(data: BaseModule.EventData<boolean>): Promise<void>;
+  onReady(data: BaseModule.EventData<true>): Promise<void>;
+  onDisable(data: BaseModule.EventData<boolean>): Promise<void>;
+  report(reason: any): Promise<RecipleAnticrash.Report[]>;
+  createReportMessageOptions(reason: any, stack: string): Promise<BaseMessageOptions$1>;
+  resolveChannel(resolvable: Exclude<RecipleAnticrash.Options['reportChannels'], undefined>[0]): Promise<SendableChannels | null>;
+  private _captureErrorEvent;
+}
+declare namespace RecipleAnticrash {
+  interface Options {
+    baseReportMessageOptions?: BaseMessageOptions | ((reason: any) => Awaitable<BaseMessageOptions>);
+    reportChannels?: (string | {
+      id: string;
+    } | SendableChannels | (() => Awaitable<SendableChannels>))[];
+  }
+  interface Report {
+    message?: Message;
+    stackTrace: string;
+    timestamp: number;
+  }
+  interface BaseMessageOptions extends BaseMessageOptions$1 {
+    replaceEmbeds?: 'merge' | boolean;
+    replaceFiles?: 'merge' | boolean;
+  }
+}
+//#endregion
+export { RecipleAnticrash };
+//# sourceMappingURL=RecipleAnticrash.d.mts.map

package/dist/classes/modules/RecipleAnticrash.mjs

@@ -0,0 +1,78 @@
+import { AttachmentBuilder, BaseChannel, Colors, EmbedBuilder, codeBlock, escapeCodeBlock } from "discord.js";
+import { inspect } from "node:util";
+import { BaseModule } from "reciple";
+
+//#region src/classes/modules/RecipleAnticrash.ts
+var RecipleAnticrash = class extends BaseModule {
+	id = "org.reciple.js.anticrash";
+	baseReportMessageOptions;
+	reportChannels = [];
+	logger = useLogger().clone({ label: "Anticrash" });
+	constructor(options) {
+		super();
+		Object.assign(this, options ?? {});
+		this._captureErrorEvent = this._captureErrorEvent.bind(this);
+	}
+	async onEnable(data) {
+		this.client.on("error", this._captureErrorEvent);
+		this.client.on("shardError", this._captureErrorEvent);
+		process.on("uncaughtException", this._captureErrorEvent);
+		process.on("uncaughtExceptionMonitor", this._captureErrorEvent);
+		process.on("unhandledRejection", this._captureErrorEvent);
+	}
+	async onReady(data) {}
+	async onDisable(data) {
+		this.client.off("error", this._captureErrorEvent);
+		this.client.off("shardError", this._captureErrorEvent);
+		process.off("uncaughtException", this._captureErrorEvent);
+		process.off("uncaughtExceptionMonitor", this._captureErrorEvent);
+		process.off("unhandledRejection", this._captureErrorEvent);
+	}
+	async report(reason) {
+		const reports = [];
+		const stack = inspect(reason, { colors: false });
+		this.logger.err(reason);
+		for (const channelId of this.reportChannels) {
+			const channel = await this.resolveChannel(channelId);
+			if (!channel) continue;
+			const message = await channel.send(await this.createReportMessageOptions(reason, stack)).catch(() => null);
+			if (message) reports.push({
+				message,
+				stackTrace: stack,
+				timestamp: message.createdTimestamp
+			});
+		}
+		return reports;
+	}
+	async createReportMessageOptions(reason, stack) {
+		const base = typeof this.baseReportMessageOptions === "function" ? await Promise.resolve(this.baseReportMessageOptions(reason)).catch(() => null) : this.baseReportMessageOptions ?? {};
+		const embed = new EmbedBuilder().setAuthor({ name: `Anticrash report` }).setTitle(String(reason).substring(0, 100)).setColor(Colors.Red).setTimestamp();
+		let files = [...base?.files ?? []];
+		if (stack.length < 1950) embed.setDescription(codeBlock(escapeCodeBlock(stack)));
+		else {
+			const file = new AttachmentBuilder(Buffer.from(stack, "utf-8"), { name: "report.log" });
+			if (base?.replaceFiles) files = [file];
+			else if (base?.replaceFiles === void 0 || base?.replaceFiles === "merge") files.push(file);
+		}
+		return {
+			...base,
+			embeds: base?.replaceEmbeds ? [embed] : base?.replaceEmbeds === void 0 || base?.replaceEmbeds === "merge" ? [...base?.embeds ?? [], embed] : base.embeds,
+			files
+		};
+	}
+	async resolveChannel(resolvable) {
+		if (resolvable instanceof BaseChannel) return resolvable;
+		if (typeof resolvable === "function") return Promise.resolve(resolvable()).catch(() => null);
+		const id = typeof resolvable === "string" ? resolvable : resolvable.id;
+		const channel = await this.client.channels.fetch(id).catch(() => null);
+		if (channel) return channel.isSendable() ? channel : null;
+		return (await this.client.users.fetch(id).catch(() => null))?.dmChannel ?? null;
+	}
+	async _captureErrorEvent(...args) {
+		if (args[0]) await this.report(args[0]);
+	}
+};
+
+//#endregion
+export { RecipleAnticrash };
+//# sourceMappingURL=RecipleAnticrash.mjs.map

package/dist/classes/modules/RecipleAnticrash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecipleAnticrash.mjs","names":[],"sources":["../../../src/classes/modules/RecipleAnticrash.ts"],"sourcesContent":["import { AttachmentBuilder, BaseChannel, codeBlock, Colors, EmbedBuilder, escapeCodeBlock, type Awaitable, type BaseMessageOptions as DJSBaseMessageOptions, type Message, type SendableChannels } from 'discord.js';\nimport { inspect } from 'node:util';\nimport { BaseModule } from 'reciple';\n\nexport class RecipleAnticrash extends BaseModule implements RecipleAnticrash.Options {\n    public readonly id: string = 'org.reciple.js.anticrash';\n\n    public baseReportMessageOptions?: RecipleAnticrash.Options['baseReportMessageOptions'];\n    public reportChannels: string[] = [];\n\n    private readonly logger = useLogger().clone({ label: 'Anticrash' });\n\n    constructor(options?: RecipleAnticrash.Options) {\n        super();\n\n        Object.assign(this, options ?? {});\n\n        this._captureErrorEvent = this._captureErrorEvent.bind(this);\n    }\n\n    public async onEnable(data: BaseModule.EventData<boolean>): Promise<void> {\n        this.client.on('error', this._captureErrorEvent);\n        this.client.on('shardError', this._captureErrorEvent);\n        process.on('uncaughtException', this._captureErrorEvent);\n        process.on('uncaughtExceptionMonitor', this._captureErrorEvent);\n        process.on('unhandledRejection', this._captureErrorEvent);\n    }\n\n    public async onReady(data: BaseModule.EventData<true>): Promise<void> {}\n\n    public async onDisable(data: BaseModule.EventData<boolean>): Promise<void> {\n        this.client.off('error', this._captureErrorEvent);\n        this.client.off('shardError', this._captureErrorEvent);\n        process.off('uncaughtException', this._captureErrorEvent);\n        process.off('uncaughtExceptionMonitor', this._captureErrorEvent);\n        process.off('unhandledRejection', this._captureErrorEvent);\n    }\n\n    public async report(reason: any): Promise<RecipleAnticrash.Report[]> {\n        const reports: RecipleAnticrash.Report[] = [];\n        const stack = inspect(reason, { colors: false });\n\n        this.logger.err(reason);\n\n        for (const channelId of this.reportChannels) {\n            const channel = await this.resolveChannel(channelId);\n            if (!channel) continue;\n\n            const message = await channel.send(await this.createReportMessageOptions(reason, stack)).catch(() => null);\n            if (message) reports.push({ message, stackTrace: stack, timestamp: message.createdTimestamp });\n        }\n\n        return reports;\n    }\n\n    public async createReportMessageOptions(reason: any, stack: string): Promise<DJSBaseMessageOptions> {\n        const base = typeof this.baseReportMessageOptions === 'function'\n            ? await Promise.resolve(this.baseReportMessageOptions(reason)).catch(() => null)\n            : this.baseReportMessageOptions ?? {};\n\n        const embed = new EmbedBuilder()\n            .setAuthor({ name: `Anticrash report` })\n            .setTitle(String(reason).substring(0, 100))\n            .setColor(Colors.Red)\n            .setTimestamp();\n\n        let files: Exclude<DJSBaseMessageOptions['files'], undefined>[0][] = [...(base?.files ?? [])];\n\n        if (stack.length < 1950) {\n            embed.setDescription(codeBlock(escapeCodeBlock(stack)))\n        } else {\n            const file = new AttachmentBuilder(Buffer.from(stack, 'utf-8'), { name: 'report.log' });\n\n            if (base?.replaceFiles) {\n                files = [file];\n            } else if (base?.replaceFiles === undefined || base?.replaceFiles === 'merge') {\n                files.push(file);\n            }\n        }\n\n        return {\n            ...base,\n            embeds: base?.replaceEmbeds\n                ? [embed]\n                : base?.replaceEmbeds === undefined || base?.replaceEmbeds === 'merge'\n                    ? [...(base?.embeds ?? []), embed]\n                    : base.embeds,\n            files\n        };\n    }\n\n    public async resolveChannel(resolvable: Exclude<RecipleAnticrash.Options['reportChannels'], undefined>[0]): Promise<SendableChannels|null> {\n        if (resolvable instanceof BaseChannel) return resolvable;\n        if (typeof resolvable === 'function') return Promise.resolve(resolvable()).catch(() => null);\n\n        const id = typeof resolvable === 'string' ? resolvable : resolvable.id;\n        const channel = await this.client.channels.fetch(id).catch(() => null);\n\n        if (channel) {\n            return channel.isSendable() ? channel : null;\n        }\n\n        const userDm = await this.client.users.fetch(id).catch(() => null);\n\n        return userDm?.dmChannel ?? null;\n    }\n\n    private async _captureErrorEvent(...args: any[]): Promise<void> {\n        if (args[0]) await this.report(args[0]);\n    }\n}\n\nexport namespace RecipleAnticrash {\n    export interface Options {\n        baseReportMessageOptions?: BaseMessageOptions|((reason: any) => Awaitable<BaseMessageOptions>);\n        reportChannels?: (string|{ id: string; }|SendableChannels|(() => Awaitable<SendableChannels>))[];\n    }\n\n    export interface Report {\n        message?: Message;\n        stackTrace: string;\n        timestamp: number;\n    }\n\n    export interface BaseMessageOptions extends DJSBaseMessageOptions {\n        replaceEmbeds?: 'merge'|boolean;\n        replaceFiles?: 'merge'|boolean;\n    }\n}\n"],"mappings":"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"}

package/dist/classes/modules/RecipleInteractionEvents.d.mts

@@ -0,0 +1,35 @@
+import { InteractionListenerType } from "../../helpers/constants.mjs";
+import { InteractionListener } from "../InteractionListener.mjs";
+import { Awaitable, CacheType, Collection, Interaction } from "discord.js";
+import { AnyModule, ClientEventModule } from "reciple";
+
+//#region src/classes/modules/RecipleInteractionEvents.d.ts
+declare class RecipleInteractionEvents extends ClientEventModule<'interactionCreate'> implements RecipleInteractionEvents.Options {
+  readonly id: string;
+  event: "interactionCreate";
+  moduleEventListenersProperty: string | string[];
+  ignoredModules?: (module: AnyModule) => Awaitable<boolean>;
+  listeners: Collection<string, InteractionListener<InteractionListenerType>>;
+  private readonly logger;
+  constructor(options?: RecipleInteractionEvents.Options);
+  onReady(): Promise<void>;
+  onEvent(interaction: Interaction<CacheType>): Promise<void>;
+  resolveListeners(customModules?: AnyModule[]): Promise<InteractionListener<InteractionListenerType>[]>;
+}
+declare namespace RecipleInteractionEvents {
+  interface Options {
+    /**
+     * The property that is scanned from modules to get interaction listeners.
+     */
+    moduleEventListenersProperty?: string | string[];
+    /**
+     * Filter modules that should be ignored.
+     */
+    ignoredModules?: (module: AnyModule) => Awaitable<boolean>;
+  }
+  type ListenerModule<P extends string, T extends InteractionListenerType> = AnyModule & Record<P, InteractionListener.Resolvable<T>[]>;
+  function getInteractionTypeFromInteraction(interaction: Interaction): InteractionListenerType;
+}
+//#endregion
+export { RecipleInteractionEvents };
+//# sourceMappingURL=RecipleInteractionEvents.d.mts.map

package/dist/classes/modules/RecipleInteractionEvents.mjs

@@ -0,0 +1,82 @@
+import { InteractionListenerType } from "../../helpers/constants.mjs";
+import { InteractionListener } from "../InteractionListener.mjs";
+import { Collection } from "discord.js";
+import { ClientEventModule } from "reciple";
+
+//#region src/classes/modules/RecipleInteractionEvents.ts
+var RecipleInteractionEvents = class RecipleInteractionEvents extends ClientEventModule {
+	id = "org.reciple.js.interaction-events";
+	event = "interactionCreate";
+	moduleEventListenersProperty = "interactions";
+	ignoredModules;
+	listeners = new Collection();
+	logger = useLogger().clone({ label: "InteractionEvents" });
+	constructor(options = {}) {
+		super();
+		Object.assign(this, options);
+	}
+	async onReady() {
+		this.client.modules.on("readyModules", async (modules) => {
+			this.logger.debug(`Resolving listeners for ready modules...`);
+			for (const listener of await this.resolveListeners(modules)) this.listeners.set(listener.id, listener);
+		});
+		this.client.modules.on("disabledModules", async (modules) => {
+			this.logger.debug(`Sweeping listeners for disabled modules...`);
+			for (const module of modules) this.listeners.sweep((listener) => listener.moduleId === module.id);
+		});
+	}
+	async onEvent(interaction) {
+		const type = RecipleInteractionEvents.getInteractionTypeFromInteraction(interaction);
+		const listeners = this.listeners.filter((listener) => listener.type === type);
+		this.logger.debug(`Triggered (${listeners.size}) listeners for interaction type "${InteractionListenerType[type]}".`);
+		for (const [id, listener] of listeners) {
+			if (!await Promise.resolve(listener.filter(interaction))) continue;
+			await Promise.resolve(listener.execute(interaction));
+			if (listener.once) {
+				this.logger.debug(`Removed listener "${id}" for interaction type "${InteractionListenerType[type]}".`);
+				this.listeners.delete(id);
+			}
+		}
+	}
+	async resolveListeners(customModules) {
+		this.logger.debug(`Resolving listeners from (${customModules?.length ?? this.client.modules.cache.size}) modules...`);
+		const modules = customModules ?? this.client.modules.cache.map((m) => m);
+		const listenersProperty = Array.isArray(this.moduleEventListenersProperty) ? this.moduleEventListenersProperty : [this.moduleEventListenersProperty];
+		const listeners = [];
+		for (const module of modules) {
+			if (module.id === this.id) continue;
+			this.logger.debug(`Resolving listeners from module "${module.id}"...`);
+			propertyLoop: for (const listenerProperty of listenersProperty) {
+				if (!(listenerProperty in module)) continue propertyLoop;
+				if (!Array.isArray(module[listenerProperty]) || !module[listenerProperty].length) continue;
+				if (typeof this.ignoredModules === "function" && await Promise.resolve(this.ignoredModules(module))) continue;
+				const moduleListeners = module[listenerProperty];
+				this.logger.debug(`Resolving listeners from module "${module.id}" with property "${listenerProperty}"...`);
+				for (const data of moduleListeners) {
+					const listener = InteractionListener.from(data);
+					Reflect.set(listener, "moduleId", module.id);
+					listeners.push(listener);
+				}
+				this.logger.debug(`Resolved (${moduleListeners.length}) listeners from module "${module.id}" with property "${listenerProperty}".`);
+			}
+		}
+		return listeners;
+	}
+};
+(function(_RecipleInteractionEvents) {
+	function getInteractionTypeFromInteraction(interaction) {
+		if (interaction.isAutocomplete()) return InteractionListenerType.Autocomplete;
+		else if (interaction.isChatInputCommand()) return InteractionListenerType.ChatInput;
+		else if (interaction.isContextMenuCommand()) return InteractionListenerType.ContextMenu;
+		else if (interaction.isModalSubmit()) return InteractionListenerType.ModalSubmit;
+		else if (interaction.isButton()) return InteractionListenerType.Button;
+		else if (interaction.isAnySelectMenu()) return InteractionListenerType.SelectMenu;
+		else if (interaction.isPrimaryEntryPointCommand()) return InteractionListenerType.PrimaryEntryPoint;
+		throw new Error(`Unknown interaction type.`);
+	}
+	_RecipleInteractionEvents.getInteractionTypeFromInteraction = getInteractionTypeFromInteraction;
+})(RecipleInteractionEvents || (RecipleInteractionEvents = {}));
+
+//#endregion
+export { RecipleInteractionEvents };
+//# sourceMappingURL=RecipleInteractionEvents.mjs.map

package/dist/classes/modules/RecipleInteractionEvents.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecipleInteractionEvents.mjs","names":[],"sources":["../../../src/classes/modules/RecipleInteractionEvents.ts"],"sourcesContent":["import { type Interaction, type CacheType, type Awaitable, Collection } from 'discord.js';\nimport { ClientEventModule, type AnyModule } from 'reciple';\nimport { InteractionListener } from '../InteractionListener.js';\nimport { InteractionListenerType } from '../../helpers/constants.js';\n\nexport class RecipleInteractionEvents extends ClientEventModule<'interactionCreate'> implements RecipleInteractionEvents.Options {\n    public readonly id: string = 'org.reciple.js.interaction-events';\n    public event = 'interactionCreate' as const;\n    public moduleEventListenersProperty: string|string[] = 'interactions';\n    public ignoredModules?: (module: AnyModule) => Awaitable<boolean>;\n    public listeners: Collection<string, InteractionListener<InteractionListenerType>> = new Collection();\n\n    private readonly logger = useLogger().clone({ label: 'InteractionEvents' });\n\n    constructor(options: RecipleInteractionEvents.Options = {}) {\n        super();\n\n        Object.assign(this, options);\n    }\n\n    public async onReady(): Promise<void> {\n        this.client.modules.on('readyModules', async (modules: AnyModule[]) => {\n            this.logger.debug(`Resolving listeners for ready modules...`);\n\n            for (const listener of await this.resolveListeners(modules)) {\n                this.listeners.set(listener.id, listener);\n            }\n        });\n\n        this.client.modules.on('disabledModules', async (modules: AnyModule[]) => {\n            this.logger.debug(`Sweeping listeners for disabled modules...`);\n\n            for (const module of modules) {\n                this.listeners.sweep(listener => listener.moduleId === module.id)\n            }\n        });\n    }\n\n    public async onEvent(interaction: Interaction<CacheType>): Promise<void> {\n        const type = RecipleInteractionEvents.getInteractionTypeFromInteraction(interaction);\n        const listeners = this.listeners.filter(listener => listener.type === type);\n\n        this.logger.debug(`Triggered (${listeners.size}) listeners for interaction type \"${InteractionListenerType[type]}\".`);\n\n        for (const [id, listener] of listeners) {\n            if (!await Promise.resolve(listener.filter(interaction))) continue;\n\n            await Promise.resolve(listener.execute(interaction));\n\n            if (listener.once) {\n                this.logger.debug(`Removed listener \"${id}\" for interaction type \"${InteractionListenerType[type]}\".`);\n                this.listeners.delete(id);\n            }\n        }\n    }\n\n    public async resolveListeners(customModules?: AnyModule[]) {\n        this.logger.debug(`Resolving listeners from (${customModules?.length ?? this.client.modules.cache.size}) modules...`);\n\n        const modules = (customModules ?? this.client.modules.cache.map(m => m)) as RecipleInteractionEvents.ListenerModule<string, InteractionListenerType>[];\n        const listenersProperty = Array.isArray(this.moduleEventListenersProperty) ? this.moduleEventListenersProperty : [this.moduleEventListenersProperty];\n        const listeners: InteractionListener<InteractionListenerType>[] = [];\n\n        for (const module of modules) {\n            if (module.id === this.id) continue;\n\n            this.logger.debug(`Resolving listeners from module \"${module.id}\"...`);\n\n            propertyLoop: for (const listenerProperty of listenersProperty) {\n                if (!(listenerProperty in module)) continue propertyLoop;\n                if (!Array.isArray(module[listenerProperty]) || !module[listenerProperty].length) continue;\n                if (typeof this.ignoredModules === 'function' && await Promise.resolve(this.ignoredModules(module))) continue;\n\n                const moduleListeners = module[listenerProperty];\n\n                this.logger.debug(`Resolving listeners from module \"${module.id}\" with property \"${listenerProperty}\"...`);\n\n                for (const data of moduleListeners) {\n                    const listener = InteractionListener.from(data);\n\n                    Reflect.set(listener, 'moduleId', module.id);\n                    listeners.push(listener);\n                }\n\n                this.logger.debug(`Resolved (${moduleListeners.length}) listeners from module \"${module.id}\" with property \"${listenerProperty}\".`);\n            }\n        }\n\n        return listeners;\n    }\n}\n\nexport namespace RecipleInteractionEvents {\n    export interface Options {\n        /**\n         * The property that is scanned from modules to get interaction listeners.\n         */\n        moduleEventListenersProperty?: string|string[];\n        /**\n         * Filter modules that should be ignored.\n         */\n        ignoredModules?: (module: AnyModule) => Awaitable<boolean>;\n    }\n\n    export type ListenerModule<P extends string, T extends InteractionListenerType> = AnyModule & Record<P, InteractionListener.Resolvable<T>[]>;\n\n    export function getInteractionTypeFromInteraction(interaction: Interaction): InteractionListenerType {\n        if (interaction.isAutocomplete()) {\n            return InteractionListenerType.Autocomplete;\n        } else if (interaction.isChatInputCommand()) {\n            return InteractionListenerType.ChatInput;\n        } else if (interaction.isContextMenuCommand()) {\n            return InteractionListenerType.ContextMenu;\n        } else if (interaction.isModalSubmit()) {\n            return InteractionListenerType.ModalSubmit;\n        } else if (interaction.isButton()) {\n            return InteractionListenerType.Button;\n        } else if (interaction.isAnySelectMenu()) {\n            return InteractionListenerType.SelectMenu;\n        } else if (interaction.isPrimaryEntryPointCommand()) {\n            return InteractionListenerType.PrimaryEntryPoint;\n        }\n\n        throw new Error(`Unknown interaction type.`);\n    }\n}\n"],"mappings":"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"}

package/dist/classes/modules/RecipleRegistryCache.d.mts

@@ -0,0 +1,54 @@
+import { AnyCommandData, BaseModule, Config, MessageCommand } from "reciple";
+
+//#region src/classes/modules/RecipleRegistryCache.d.ts
+declare class RecipleRegistryCache extends BaseModule implements RecipleRegistryCache.Options {
+  readonly id: string;
+  createCacheEntryEvenIfDisabled: boolean;
+  cacheDir: string;
+  maxCacheAgeMs?: number;
+  cacheEnabledEnv: string;
+  cached: boolean;
+  private readonly logger;
+  constructor(options?: RecipleRegistryCache.Options);
+  get cachePath(): string;
+  onReady(): Promise<void>;
+  readCacheEntry(): Promise<RecipleRegistryCache.CacheEntry | null>;
+  writeCacheEntry(entry?: RecipleRegistryCache.CacheEntry): Promise<void>;
+  clearCacheEntry(): Promise<void>;
+  createCacheEntry(): Promise<RecipleRegistryCache.CacheEntry>;
+  isCacheHit(cached: RecipleRegistryCache.CacheEntry, current: RecipleRegistryCache.CacheEntry): boolean;
+  private isEnabled;
+}
+declare namespace RecipleRegistryCache {
+  interface Options {
+    /**
+     * @default true
+     */
+    createCacheEntryEvenIfDisabled?: boolean;
+    /**
+     * @default '.cache/reciple-registry/'
+     */
+    cacheDir?: string;
+    /**
+     * @default 86400000 // 24 hours in milliseconds
+     */
+    maxCacheAgeMs?: number;
+    /**
+     * @default 'RECIPLE_REGISTRY_CACHE'
+     */
+    cacheEnabledEnv?: string;
+  }
+  interface CacheEntry {
+    commandsHash: string;
+    configHash: string;
+    createdAt: number;
+  }
+  type CommandData = Exclude<AnyCommandData, MessageCommand.Data>;
+  function checkClientIfEnabled(config: Config): boolean;
+  function createCommandsHash(commands: Exclude<AnyCommandData, MessageCommand.Data>[]): string;
+  function createConfigHash(config: Config): string;
+  function stringifyValue(object: any): string;
+}
+//#endregion
+export { RecipleRegistryCache };
+//# sourceMappingURL=RecipleRegistryCache.d.mts.map

package/dist/classes/modules/RecipleRegistryCache.mjs

@@ -0,0 +1,150 @@
+import { BaseModule, CommandType } from "reciple";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+//#region src/classes/modules/RecipleRegistryCache.ts
+var RecipleRegistryCache = class RecipleRegistryCache extends BaseModule {
+	id = "org.reciple.js.registry-cache";
+	createCacheEntryEvenIfDisabled = true;
+	cacheDir = path.join(process.cwd(), ".cache/reciple-registry/");
+	maxCacheAgeMs;
+	cacheEnabledEnv = "RECIPLE_REGISTRY_CACHE";
+	cached = false;
+	logger = useLogger().clone({ label: "RegistryCache" });
+	constructor(options) {
+		super();
+		Object.assign(this, options ?? {});
+	}
+	get cachePath() {
+		return path.join(this.cacheDir, this.client.application?.id ?? "cache.json");
+	}
+	async onReady() {
+		const enabled = this.isEnabled();
+		if (enabled || this.createCacheEntryEvenIfDisabled) this.client.commands?.once("applicationCommandsRegister", async (commands, guildId) => {
+			await this.writeCacheEntry();
+		});
+		if (!enabled) {
+			this.client.modules.on("readyModules", async () => {
+				this.logger.warn(`Registry cache is disabled. Cache is not used.`);
+			});
+			return;
+		}
+		this.logger.debug("Looking for a application commands cache entry...");
+		const cachedEntry = await this.readCacheEntry();
+		this.logger.debug("Creating current application commands cache entry...");
+		const currentEntry = await this.createCacheEntry();
+		if (cachedEntry && this.isCacheHit(cachedEntry, currentEntry)) {
+			this.client.config.applicationCommandsRegister = {
+				...this.client.config.applicationCommandsRegister,
+				registerGlobally: false,
+				registerToGuilds: false
+			};
+			this.cached = true;
+		}
+		this.client.modules.on("readyModules", async () => {
+			this.logger.warn(`Application commands are ${this.cached ? "" : "not "}cached. ${this.cached ? "Skipping" : "Proceeding with"} registration.`);
+		});
+	}
+	async readCacheEntry() {
+		if (!await stat(this.cachePath).catch(() => null)) return null;
+		return await readFile(this.cachePath, "utf-8").then(JSON.parse).catch(() => null);
+	}
+	async writeCacheEntry(entry) {
+		entry ??= await this.createCacheEntry();
+		this.logger.debug("Writing application commands cache entry...");
+		await mkdir(this.cacheDir, { recursive: true });
+		await writeFile(this.cachePath, JSON.stringify(entry, null, 4), "utf-8");
+		this.logger.debug(`Application commands cache entry written to "${this.cachePath}".`);
+	}
+	async clearCacheEntry() {
+		await rm(this.cachePath).catch(() => null);
+	}
+	async createCacheEntry() {
+		this.logger.debug("Creating current application commands cache entry...");
+		const commands = Array.from(this.client.commands?.cache.filter((cmd) => cmd.type !== CommandType.Message).map((cmd) => cmd.toJSON()).values() ?? []);
+		for (const command of commands) Object.assign(command, { id: "[cache_value]" });
+		const commandsHash = RecipleRegistryCache.createCommandsHash(commands);
+		const configHash = RecipleRegistryCache.createConfigHash(this.client.config?.applicationCommandsRegister ?? {});
+		this.logger.debug(`Commands hash: ${commandsHash}`);
+		this.logger.debug(`Config hash: ${configHash}`);
+		this.logger.debug("Current application commands cache entry created.");
+		return {
+			createdAt: Date.now(),
+			commandsHash,
+			configHash
+		};
+	}
+	isCacheHit(cached, current) {
+		this.logger.debug("Comparing cache entry with current application commands and configuration...");
+		if (this.maxCacheAgeMs) {
+			const age = Date.now() - cached.createdAt;
+			if (age > this.maxCacheAgeMs) {
+				this.logger.debug(`Cache entry is too old (age: ${age}ms, max age: ${this.maxCacheAgeMs}ms).`);
+				return false;
+			}
+		}
+		if (cached.commandsHash !== current.commandsHash) {
+			this.logger.debug(`Cache entry commands hash doesn't match (cached: ${cached.commandsHash}, current: ${current.commandsHash}).`);
+			return false;
+		}
+		if (cached.configHash !== current.configHash) {
+			this.logger.debug(`Cache entry config hash doesn't match (cached: ${cached.configHash}, current: ${current.configHash}).`);
+			return false;
+		}
+		this.logger.debug("Cache entry matches current application commands and configuration.");
+		return true;
+	}
+	isEnabled() {
+		if (process.env[this.cacheEnabledEnv] !== "false" && process.env[this.cacheEnabledEnv] !== "0") return RecipleRegistryCache.checkClientIfEnabled(this.client.config ?? {});
+		return false;
+	}
+};
+(function(_RecipleRegistryCache) {
+	function checkClientIfEnabled(config) {
+		return config.applicationCommandsRegister?.registerGlobally || config.applicationCommandsRegister?.registerToGuilds === true || Array.isArray(config.applicationCommandsRegister?.registerToGuilds) && config.applicationCommandsRegister?.registerToGuilds.length > 0;
+	}
+	_RecipleRegistryCache.checkClientIfEnabled = checkClientIfEnabled;
+	function createCommandsHash(commands) {
+		const hash = createHash("sha256");
+		hash.update(stringifyValue(commands));
+		return hash.digest("hex");
+	}
+	_RecipleRegistryCache.createCommandsHash = createCommandsHash;
+	function createConfigHash(config) {
+		const hash = createHash("sha256");
+		const relevantConfig = { applicationCommandsRegister: config.applicationCommandsRegister };
+		hash.update(stringifyValue(relevantConfig));
+		return hash.digest("hex");
+	}
+	_RecipleRegistryCache.createConfigHash = createConfigHash;
+	function stringifyValue(object) {
+		switch (typeof object) {
+			case "string": return `"${object}"`;
+			case "number":
+			case "bigint":
+			case "boolean":
+			case "symbol":
+			case "function": return `"${object.toString()}"`;
+			case "undefined": return "undefined";
+			case "object":
+				if (object === null) return "null";
+				if (Array.isArray(object)) return `[${object.map((s) => stringifyValue(s)).join(", ")}]`;
+				if (object instanceof Map) return `{${Array.from(object.entries()).map(([k, v]) => `${stringifyValue(k)}: ${stringifyValue(v)}`).join(", ")}}`;
+				if (object instanceof Set) return `{${Array.from(object.values()).map((v) => stringifyValue(v)).join(", ")}}`;
+				if (object instanceof Date) return `"${object.toISOString()}"`;
+				try {
+					const newObject = {};
+					for (const [key, value] of Object.entries(object)) newObject[key] = stringifyValue(value);
+					return JSON.stringify(newObject);
+				} catch {
+					return String(object);
+				}
+		}
+	}
+	_RecipleRegistryCache.stringifyValue = stringifyValue;
+})(RecipleRegistryCache || (RecipleRegistryCache = {}));
+
+//#endregion
+export { RecipleRegistryCache };
+//# sourceMappingURL=RecipleRegistryCache.mjs.map

package/dist/classes/modules/RecipleRegistryCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecipleRegistryCache.mjs","names":[],"sources":["../../../src/classes/modules/RecipleRegistryCache.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\nimport { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { BaseModule, CommandType, type AnyCommandData, type Config, type MessageCommand } from 'reciple';\n\nexport class RecipleRegistryCache extends BaseModule implements RecipleRegistryCache.Options {\n    public readonly id: string = 'org.reciple.js.registry-cache';\n\n    public createCacheEntryEvenIfDisabled: boolean = true;\n    public cacheDir: string = path.join(process.cwd(), '.cache/reciple-registry/');\n    public maxCacheAgeMs?: number;\n    public cacheEnabledEnv: string = 'RECIPLE_REGISTRY_CACHE';\n    public cached: boolean = false;\n\n    private readonly logger = useLogger().clone({ label: 'RegistryCache' });\n\n    constructor(options?: RecipleRegistryCache.Options) {\n        super();\n        Object.assign(this, options ?? {});\n    }\n\n    get cachePath(): string {\n        return path.join(this.cacheDir, this.client.application?.id ?? 'cache.json');\n    }\n\n    public async onReady(): Promise<void> {\n        const enabled = this.isEnabled();\n\n        if (enabled || this.createCacheEntryEvenIfDisabled) {\n            this.client.commands?.once('applicationCommandsRegister', async (commands, guildId) => {\n                await this.writeCacheEntry();\n            });\n        }\n\n        if (!enabled) {\n            this.client.modules.on('readyModules', async () => {\n                this.logger.warn(`Registry cache is disabled. Cache is not used.`);\n            });\n\n            return;\n        }\n\n        this.logger.debug('Looking for a application commands cache entry...');\n        const cachedEntry = await this.readCacheEntry();\n\n        this.logger.debug('Creating current application commands cache entry...');\n        const currentEntry = await this.createCacheEntry();\n\n        if (cachedEntry && this.isCacheHit(cachedEntry, currentEntry)) {\n            this.client.config!.applicationCommandsRegister = {\n                ...this.client.config!.applicationCommandsRegister,\n                registerGlobally: false,\n                registerToGuilds: false\n            }\n\n            this.cached = true;\n        }\n\n        this.client.modules.on('readyModules', async () => {\n            this.logger.warn(`Application commands are ${this.cached ? '' : 'not '}cached. ${this.cached ? 'Skipping' : 'Proceeding with'} registration.`);\n        });\n    }\n\n    public async readCacheEntry(): Promise<RecipleRegistryCache.CacheEntry|null> {\n        const stats = await stat(this.cachePath).catch(() => null);\n        if (!stats) return null;\n\n        return await readFile(this.cachePath, 'utf-8').then(JSON.parse).catch(() => null);\n    }\n\n    public async writeCacheEntry(entry?: RecipleRegistryCache.CacheEntry): Promise<void> {\n        entry ??= await this.createCacheEntry();\n\n        this.logger.debug('Writing application commands cache entry...');\n        await mkdir(this.cacheDir, { recursive: true });\n        await writeFile(this.cachePath, JSON.stringify(entry, null, 4), 'utf-8');\n\n        this.logger.debug(`Application commands cache entry written to \"${this.cachePath}\".`);\n    }\n\n    public async clearCacheEntry(): Promise<void> {\n        await rm(this.cachePath).catch(() => null);\n    }\n\n    public async createCacheEntry(): Promise<RecipleRegistryCache.CacheEntry> {\n        this.logger.debug('Creating current application commands cache entry...');\n        const commands = Array.from(this.client.commands?.cache.filter(cmd => cmd.type !== CommandType.Message).map(cmd => cmd.toJSON()).values() ?? []);\n\n        for (const command of commands) {\n            Object.assign(command, { id: \"[cache_value]\" });\n        }\n\n        const commandsHash = RecipleRegistryCache.createCommandsHash(commands);\n        const configHash = RecipleRegistryCache.createConfigHash(this.client.config?.applicationCommandsRegister ?? {});\n\n        this.logger.debug(`Commands hash: ${commandsHash}`);\n        this.logger.debug(`Config hash: ${configHash}`);\n        this.logger.debug('Current application commands cache entry created.');\n\n        return {\n            createdAt: Date.now(),\n            commandsHash,\n            configHash\n        };\n    }\n\n    public isCacheHit(cached: RecipleRegistryCache.CacheEntry, current: RecipleRegistryCache.CacheEntry): boolean {\n        this.logger.debug('Comparing cache entry with current application commands and configuration...');\n        if (this.maxCacheAgeMs) {\n            const age = Date.now() - cached.createdAt;\n            if (age > this.maxCacheAgeMs) {\n                this.logger.debug(`Cache entry is too old (age: ${age}ms, max age: ${this.maxCacheAgeMs}ms).`);\n                return false;\n            }\n        }\n\n        if (cached.commandsHash !== current.commandsHash) {\n            this.logger.debug(`Cache entry commands hash doesn't match (cached: ${cached.commandsHash}, current: ${current.commandsHash}).`);\n            return false;\n        }\n        if (cached.configHash !== current.configHash) {\n            this.logger.debug(`Cache entry config hash doesn't match (cached: ${cached.configHash}, current: ${current.configHash}).`);\n            return false;\n        }\n\n        this.logger.debug('Cache entry matches current application commands and configuration.');\n        return true;\n    }\n\n    private isEnabled(): boolean {\n        if (process.env[this.cacheEnabledEnv] !== 'false' && process.env[this.cacheEnabledEnv] !== '0') {\n            return RecipleRegistryCache.checkClientIfEnabled(this.client.config ?? {});\n        }\n\n        return false;\n    }\n}\n\nexport namespace RecipleRegistryCache {\n    export interface Options {\n        /**\n         * @default true\n         */\n        createCacheEntryEvenIfDisabled?: boolean;\n        /**\n         * @default '.cache/reciple-registry/'\n         */\n        cacheDir?: string;\n        /**\n         * @default 86400000 // 24 hours in milliseconds\n         */\n        maxCacheAgeMs?: number;\n        /**\n         * @default 'RECIPLE_REGISTRY_CACHE'\n         */\n        cacheEnabledEnv?: string;\n    }\n\n    export interface CacheEntry {\n        commandsHash: string;\n        configHash: string;\n        createdAt: number;\n    }\n\n    export type CommandData = Exclude<AnyCommandData, MessageCommand.Data>;\n\n    export function checkClientIfEnabled(config: Config): boolean {\n        return config.applicationCommandsRegister?.registerGlobally\n            || config.applicationCommandsRegister?.registerToGuilds === true\n            || (\n                Array.isArray(config.applicationCommandsRegister?.registerToGuilds)\n                && config.applicationCommandsRegister?.registerToGuilds.length > 0\n            );\n    }\n\n    export function createCommandsHash(commands: Exclude<AnyCommandData, MessageCommand.Data>[]): string {\n        const hash = createHash('sha256');\n\n        hash.update(stringifyValue(commands));\n\n        return hash.digest('hex');\n    }\n\n    export function createConfigHash(config: Config): string {\n        const hash = createHash('sha256');\n        const relevantConfig = { applicationCommandsRegister: config.applicationCommandsRegister };\n\n        hash.update(stringifyValue(relevantConfig));\n\n        return hash.digest('hex');\n    }\n\n    export function stringifyValue(object: any): string {\n        switch (typeof object) {\n            case 'string':\n                return `\"${object}\"`;\n            case 'number':\n            case 'bigint':\n            case 'boolean':\n            case 'symbol':\n            case 'function':\n                return `\"${object.toString()}\"`;\n            case 'undefined':\n                return 'undefined';\n            case 'object':\n                if (object === null) {\n                    return 'null';\n                }\n\n                if (Array.isArray(object)) {\n                    return `[${object.map(s => stringifyValue(s)).join(', ')}]`;\n                }\n\n                if (object instanceof Map) {\n                    return `{${Array.from(object.entries()).map(([k, v]) => `${stringifyValue(k)}: ${stringifyValue(v)}`).join(', ')}}`;\n                }\n\n                if (object instanceof Set) {\n                    return `{${Array.from(object.values()).map(v => stringifyValue(v)).join(', ')}}`;\n                }\n\n                if (object instanceof Date) {\n                    return `\"${object.toISOString()}\"`;\n                }\n\n                try {\n                    const newObject: Record<string, string> = {};\n\n                    for (const [key, value] of Object.entries(object)) {\n                        newObject[key] = stringifyValue(value);\n                    }\n\n                    return JSON.stringify(newObject);\n                } catch {\n                    return String(object);\n                }\n        }\n    }\n}\n"],"mappings":"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"}

package/dist/helpers/constants.d.mts

@@ -0,0 +1,13 @@
+//#region src/helpers/constants.d.ts
+declare enum InteractionListenerType {
+  Autocomplete = 1,
+  ContextMenu = 2,
+  ChatInput = 3,
+  Button = 4,
+  ModalSubmit = 5,
+  SelectMenu = 6,
+  PrimaryEntryPoint = 7
+}
+//#endregion
+export { InteractionListenerType };
+//# sourceMappingURL=constants.d.mts.map

package/dist/helpers/constants.mjs

@@ -0,0 +1,15 @@
+//#region src/helpers/constants.ts
+let InteractionListenerType = /* @__PURE__ */ function(InteractionListenerType) {
+	InteractionListenerType[InteractionListenerType["Autocomplete"] = 1] = "Autocomplete";
+	InteractionListenerType[InteractionListenerType["ContextMenu"] = 2] = "ContextMenu";
+	InteractionListenerType[InteractionListenerType["ChatInput"] = 3] = "ChatInput";
+	InteractionListenerType[InteractionListenerType["Button"] = 4] = "Button";
+	InteractionListenerType[InteractionListenerType["ModalSubmit"] = 5] = "ModalSubmit";
+	InteractionListenerType[InteractionListenerType["SelectMenu"] = 6] = "SelectMenu";
+	InteractionListenerType[InteractionListenerType["PrimaryEntryPoint"] = 7] = "PrimaryEntryPoint";
+	return InteractionListenerType;
+}({});
+
+//#endregion
+export { InteractionListenerType };
+//# sourceMappingURL=constants.mjs.map

package/dist/helpers/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../src/helpers/constants.ts"],"sourcesContent":["export enum InteractionListenerType {\n    Autocomplete = 1,\n    ContextMenu,\n    ChatInput,\n    Button,\n    ModalSubmit,\n    SelectMenu,\n    PrimaryEntryPoint\n}\n"],"mappings":";AAAA,IAAY,4EAAL;AACH;AACA;AACA;AACA;AACA;AACA;AACA"}

package/dist/helpers/types.d.mts

@@ -0,0 +1,17 @@
+import { InteractionListenerType } from "./constants.mjs";
+import { AnySelectMenuInteraction, AutocompleteInteraction, Awaitable, ButtonInteraction, ChatInputCommandInteraction, ContextMenuCommandInteraction, Interaction, ModalSubmitInteraction, PrimaryEntryPointCommandInteraction } from "discord.js";
+
+//#region src/helpers/types.d.ts
+interface InteractionListenerData<T extends InteractionListenerType = InteractionListenerType> {
+  type: T;
+  once?: boolean;
+  filter?: (interaction: InteractionFromListenerType<T>) => Awaitable<boolean>;
+  execute: (interaction: InteractionFromListenerType<T>) => Awaitable<void>;
+}
+type AnyCommandInteraction = AutocompleteInteraction | ChatInputCommandInteraction | ContextMenuCommandInteraction | PrimaryEntryPointCommandInteraction;
+type AnyComponentInteraction = ButtonInteraction | ModalSubmitInteraction | AnySelectMenuInteraction;
+type InteractionFromListenerType<T extends InteractionListenerType> = T extends InteractionListenerType.Autocomplete ? AutocompleteInteraction : T extends InteractionListenerType.ChatInput ? ChatInputCommandInteraction : T extends InteractionListenerType.ContextMenu ? ContextMenuCommandInteraction : T extends InteractionListenerType.Button ? ButtonInteraction : T extends InteractionListenerType.ModalSubmit ? ModalSubmitInteraction : T extends InteractionListenerType.SelectMenu ? AnySelectMenuInteraction : T extends InteractionListenerType.PrimaryEntryPoint ? PrimaryEntryPointCommandInteraction : Interaction;
+type ListenerTypeFromInteraction<T extends InteractionFromListenerType<InteractionListenerType>> = T extends AutocompleteInteraction ? InteractionListenerType.Autocomplete : T extends ChatInputCommandInteraction ? InteractionListenerType.ChatInput : T extends ContextMenuCommandInteraction ? InteractionListenerType.ContextMenu : T extends ButtonInteraction ? InteractionListenerType.Button : T extends ModalSubmitInteraction ? InteractionListenerType.ModalSubmit : T extends AnySelectMenuInteraction ? InteractionListenerType.SelectMenu : T extends PrimaryEntryPointCommandInteraction ? InteractionListenerType.PrimaryEntryPoint : InteractionListenerType;
+//#endregion
+export { AnyCommandInteraction, AnyComponentInteraction, InteractionFromListenerType, InteractionListenerData, ListenerTypeFromInteraction };
+//# sourceMappingURL=types.d.mts.map

package/dist/helpers/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { InteractionListenerType } from "./helpers/constants.mjs";
+import { AnyCommandInteraction, AnyComponentInteraction, InteractionFromListenerType, InteractionListenerData, ListenerTypeFromInteraction } from "./helpers/types.mjs";
+import { InteractionListener } from "./classes/InteractionListener.mjs";
+import { InteractionListenerBuilder } from "./classes/builders/InteractionListenerBuilder.mjs";
+import { RecipleAnticrash } from "./classes/modules/RecipleAnticrash.mjs";
+import { RecipleInteractionEvents } from "./classes/modules/RecipleInteractionEvents.mjs";
+import { RecipleRegistryCache } from "./classes/modules/RecipleRegistryCache.mjs";
+export { AnyCommandInteraction, AnyComponentInteraction, InteractionFromListenerType, InteractionListener, InteractionListenerBuilder, InteractionListenerData, InteractionListenerType, ListenerTypeFromInteraction, RecipleAnticrash, RecipleInteractionEvents, RecipleRegistryCache };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { InteractionListenerType } from "./helpers/constants.mjs";
+import { InteractionListenerBuilder } from "./classes/builders/InteractionListenerBuilder.mjs";
+import { RecipleAnticrash } from "./classes/modules/RecipleAnticrash.mjs";
+import { InteractionListener } from "./classes/InteractionListener.mjs";
+import { RecipleInteractionEvents } from "./classes/modules/RecipleInteractionEvents.mjs";
+import { RecipleRegistryCache } from "./classes/modules/RecipleRegistryCache.mjs";
+
+export { InteractionListener, InteractionListenerBuilder, InteractionListenerType, RecipleAnticrash, RecipleInteractionEvents, RecipleRegistryCache };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@reciple/modules",
+  "version": "10.0.1",
+  "license": "LGPL-3.0-only",
+  "description": "A collection of useful modules for reciple",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "build": "tsdown --config-loader unrun",
+    "docs": "deno doc --json --sloppy-imports ./src/index.ts > docs.json",
+    "check": "tsc --noEmit",
+    "prepack": "bun run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thenorthsolution/reciple",
+    "directory": "packages/modules"
+  },
+  "peerDependencies": {
+    "discord.js": "^14.25.1",
+    "reciple": "^10.0.1"
+  },
+  "peerDependenciesMeta": {
+    "discord.js": {
+      "optional": false
+    },
+    "reciple": {
+      "optional": false
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@sapphire/snowflake": "^3.5.5"
+  }
+}