zumito-framework 1.17.0 → 1.19.0

package/dist/services/EmojiFallback.d.ts

@@ -3,8 +3,12 @@ import { TranslationManager } from './managers/TranslationManager';
 export declare class EmojiFallback {
     client: Client;
     translator: TranslationManager;
+    private applicationEmojisPromise;
     constructor(client: Client, translator: TranslationManager);
-    getEmoji(emojiId: string, fallbackEmoji: any): any;
-    getEmojiByName(emojiName: string, fallbackEmoji: any): any;
-    getEmojiByIdentifier(emojiId: string, fallbackEmoji: any): any;
+    private ensureApplicationEmojis;
+    getEmoji(emojiId: string, fallbackEmoji: any): Promise<any>;
+    getEmojiByName(emojiName: string, fallbackEmoji: any): Promise<any>;
+    getEmojiByIdentifier(emojiId: string, fallbackEmoji: any): Promise<any>;
+    getApplicationEmoji(emojiId: string): Promise<import("discord.js").ApplicationEmoji>;
+    getApplicationEmojiByName(emojiName: string): Promise<import("discord.js").ApplicationEmoji>;
 }

package/dist/services/EmojiFallback.js

@@ -1,26 +1,65 @@
 export class EmojiFallback {
     client;
     translator;
+    applicationEmojisPromise = null;
     constructor(client, translator) {
         this.client = client;
         this.translator = translator;
     }
-    getEmoji(emojiId, fallbackEmoji) {
+    ensureApplicationEmojis() {
+        if (!this.applicationEmojisPromise) {
+            if (this.client.application) {
+                this.applicationEmojisPromise = this.client.application.emojis.fetch().catch(() => { });
+            }
+            else {
+                this.applicationEmojisPromise = Promise.resolve();
+            }
+        }
+        return this.applicationEmojisPromise;
+    }
+    async getEmoji(emojiId, fallbackEmoji) {
         if (this.translator.has(emojiId)) {
             emojiId = this.translator.get(emojiId);
         }
         const emoji = this.client.emojis.cache.get(emojiId);
-        return emoji?.toString() || fallbackEmoji;
+        if (emoji)
+            return emoji.toString();
+        const appEmoji = await this.getApplicationEmoji(emojiId);
+        if (appEmoji)
+            return appEmoji.toString();
+        return fallbackEmoji;
     }
-    getEmojiByName(emojiName, fallbackEmoji) {
+    async getEmojiByName(emojiName, fallbackEmoji) {
         const emoji = this.client.emojis.cache.find((emoji) => emoji.name === emojiName);
-        return emoji?.toString() || fallbackEmoji;
+        if (emoji)
+            return emoji.toString();
+        const appEmoji = await this.getApplicationEmojiByName(emojiName);
+        if (appEmoji)
+            return appEmoji.toString();
+        return fallbackEmoji;
     }
-    getEmojiByIdentifier(emojiId, fallbackEmoji) {
+    async getEmojiByIdentifier(emojiId, fallbackEmoji) {
         if (this.translator.has(emojiId)) {
             emojiId = this.translator.get(emojiId);
         }
         const emoji = this.client.emojis.cache.find((emoji) => emoji.id === emojiId);
-        return emoji?.toString() || fallbackEmoji;
+        if (emoji)
+            return emoji.toString();
+        const appEmoji = await this.getApplicationEmoji(emojiId);
+        if (appEmoji)
+            return appEmoji.toString();
+        return fallbackEmoji;
+    }
+    async getApplicationEmoji(emojiId) {
+        if (!this.client.application)
+            return undefined;
+        await this.ensureApplicationEmojis();
+        return this.client.application.emojis.cache.get(emojiId);
+    }
+    async getApplicationEmojiByName(emojiName) {
+        if (!this.client.application)
+            return undefined;
+        await this.ensureApplicationEmojis();
+        return this.client.application.emojis.cache.find((emoji) => emoji.name === emojiName);
     }
 }

package/dist/testing/createTestFramework.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'tseep';
+export declare function createTestFramework(overrides?: Record<string, any>): {
+    framework: any;
+    client: {
+        _listeners: Record<string, ((...args: any[]) => void)[]>;
+        on: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
+        once: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
+        emit: import("vitest").Mock<[event: string, ...args: any[]], void>;
+        login: import("vitest").Mock<any, any>;
+        destroy: import("vitest").Mock<any, any>;
+        guilds: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        user: {
+            id: string;
+            tag: string;
+            username: string;
+        };
+        users: {
+            fetch: import("vitest").Mock<any, any>;
+        };
+        options: {};
+    };
+    eventEmitter: EventEmitter<import("tseep").DefaultEventMap>;
+};

package/dist/testing/createTestFramework.js

@@ -0,0 +1,56 @@
+import { vi } from 'vitest';
+import { EventEmitter } from 'tseep';
+import { ServiceContainer } from '../services/ServiceContainer.js';
+import { createMockClient } from './mocks/discord.js';
+export function createTestFramework(overrides = {}) {
+    ServiceContainer.services.clear();
+    const mockClient = createMockClient(overrides.client);
+    const eventEmitter = new EventEmitter();
+    const mockFramework = {
+        client: mockClient,
+        commands: {
+            size: 0,
+            set: vi.fn(),
+            get: vi.fn(),
+            getAll: vi.fn().mockReturnValue(new Map()),
+        },
+        events: new Map(),
+        translations: {
+            get: vi.fn(),
+            getAll: vi.fn().mockReturnValue(new Map()),
+            registerTranslationsFromFolder: vi.fn(),
+        },
+        settings: {
+            defaultPrefix: '!',
+            ...overrides.settings,
+        },
+        eventEmitter,
+        eventManager: {
+            addEventEmitter: vi.fn(),
+            addEventListener: vi.fn(),
+            getEventEmitter: vi.fn(),
+            eventEmitters: new Map(),
+        },
+        routes: [],
+        registerRoute: vi.fn(),
+        modules: {
+            set: vi.fn(),
+            get: vi.fn(),
+            getAll: vi.fn().mockReturnValue(new Map()),
+            size: 0,
+        },
+        ...overrides.framework,
+    };
+    ServiceContainer.addService(class ZumitoFramework {
+    }, [], true, mockFramework);
+    class MockErrorHandler {
+        handleError = vi.fn();
+    }
+    ServiceContainer.addService(class ErrorHandler {
+    }, [], true, new MockErrorHandler());
+    return {
+        framework: mockFramework,
+        client: mockClient,
+        eventEmitter,
+    };
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { createTestFramework } from './createTestFramework.js';
+export { createMockClient, createMockGuild, createMockTextChannel, createMockGuildMember, createMockMessage, createMockCommandInteraction, createMockButtonInteraction, createMockStringSelectMenuInteraction, createMockModalSubmitInteraction, } from './mocks/discord.js';

package/dist/testing/index.js

@@ -0,0 +1,2 @@
+export { createTestFramework } from './createTestFramework.js';
+export { createMockClient, createMockGuild, createMockTextChannel, createMockGuildMember, createMockMessage, createMockCommandInteraction, createMockButtonInteraction, createMockStringSelectMenuInteraction, createMockModalSubmitInteraction, } from './mocks/discord.js';

package/dist/testing/mocks/discord.d.ts

@@ -0,0 +1,557 @@
+export declare function createMockClient(overrides?: Record<string, any>): {
+    _listeners: Record<string, ((...args: any[]) => void)[]>;
+    on: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
+    once: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
+    emit: import("vitest").Mock<[event: string, ...args: any[]], void>;
+    login: import("vitest").Mock<any, any>;
+    destroy: import("vitest").Mock<any, any>;
+    guilds: {
+        cache: Map<any, any>;
+        fetch: import("vitest").Mock<any, any>;
+    };
+    channels: {
+        cache: Map<any, any>;
+        fetch: import("vitest").Mock<any, any>;
+    };
+    user: {
+        id: string;
+        tag: string;
+        username: string;
+    };
+    users: {
+        fetch: import("vitest").Mock<any, any>;
+    };
+    options: {};
+};
+export declare function createMockGuild(overrides?: Record<string, any>): {
+    id: string;
+    name: string;
+    ownerId: string;
+    channels: {
+        cache: Map<any, any>;
+        fetch: import("vitest").Mock<any, any>;
+    };
+    members: {
+        cache: Map<any, any>;
+        fetch: import("vitest").Mock<any, any>;
+    };
+    roles: {
+        cache: Map<any, any>;
+    };
+};
+export declare function createMockTextChannel(overrides?: Record<string, any>): {
+    id: string;
+    type: number;
+    name: string;
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    isTextBased: import("vitest").Mock<any, any>;
+    isDMBased: import("vitest").Mock<any, any>;
+    nsfw: boolean;
+    send: import("vitest").Mock<any, any>;
+    permissionsFor: import("vitest").Mock<any, any>;
+};
+export declare function createMockGuildMember(overrides?: Record<string, any>): {
+    id: string;
+    user: {
+        id: string;
+        username: string;
+    };
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    permissions: {
+        has: import("vitest").Mock<any, any>;
+    };
+    roles: {
+        cache: Map<any, any>;
+    };
+};
+export declare function createMockMessage(overrides?: Record<string, any>): {
+    id: string;
+    content: string;
+    author: {
+        id: string;
+        user: {
+            id: string;
+            username: string;
+        };
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        permissions: {
+            has: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    channel: {
+        id: string;
+        type: number;
+        name: string;
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        isTextBased: import("vitest").Mock<any, any>;
+        isDMBased: import("vitest").Mock<any, any>;
+        nsfw: boolean;
+        send: import("vitest").Mock<any, any>;
+        permissionsFor: import("vitest").Mock<any, any>;
+    };
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    guildId: string;
+    member: {
+        id: string;
+        user: {
+            id: string;
+            username: string;
+        };
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        permissions: {
+            has: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    reply: import("vitest").Mock<any, any>;
+    delete: import("vitest").Mock<any, any>;
+    react: import("vitest").Mock<any, any>;
+    editable: boolean;
+    deletable: boolean;
+};
+export declare function createMockCommandInteraction(overrides?: Record<string, any>): {
+    id: string;
+    commandName: string;
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    guildId: string;
+    channel: {
+        id: string;
+        type: number;
+        name: string;
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        isTextBased: import("vitest").Mock<any, any>;
+        isDMBased: import("vitest").Mock<any, any>;
+        nsfw: boolean;
+        send: import("vitest").Mock<any, any>;
+        permissionsFor: import("vitest").Mock<any, any>;
+    };
+    member: {
+        id: string;
+        user: {
+            id: string;
+            username: string;
+        };
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        permissions: {
+            has: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    user: {
+        id: string;
+        username: string;
+    };
+    reply: import("vitest").Mock<any, any>;
+    deferReply: import("vitest").Mock<any, any>;
+    editReply: import("vitest").Mock<any, any>;
+    followUp: import("vitest").Mock<any, any>;
+    options: {
+        get: import("vitest").Mock<any, any>;
+        getString: import("vitest").Mock<any, any>;
+        getInteger: import("vitest").Mock<any, any>;
+        getBoolean: import("vitest").Mock<any, any>;
+        getUser: import("vitest").Mock<any, any>;
+        getChannel: import("vitest").Mock<any, any>;
+        getRole: import("vitest").Mock<any, any>;
+        getSubcommand: import("vitest").Mock<any, any>;
+    };
+};
+export declare function createMockButtonInteraction(overrides?: Record<string, any>): {
+    id: string;
+    customId: string;
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    guildId: string;
+    channel: {
+        id: string;
+        type: number;
+        name: string;
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        isTextBased: import("vitest").Mock<any, any>;
+        isDMBased: import("vitest").Mock<any, any>;
+        nsfw: boolean;
+        send: import("vitest").Mock<any, any>;
+        permissionsFor: import("vitest").Mock<any, any>;
+    };
+    member: {
+        id: string;
+        user: {
+            id: string;
+            username: string;
+        };
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        permissions: {
+            has: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    user: {
+        id: string;
+        username: string;
+    };
+    reply: import("vitest").Mock<any, any>;
+    deferReply: import("vitest").Mock<any, any>;
+    deferUpdate: import("vitest").Mock<any, any>;
+    update: import("vitest").Mock<any, any>;
+};
+export declare function createMockStringSelectMenuInteraction(overrides?: Record<string, any>): {
+    id: string;
+    customId: string;
+    values: string[];
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    guildId: string;
+    channel: {
+        id: string;
+        type: number;
+        name: string;
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        isTextBased: import("vitest").Mock<any, any>;
+        isDMBased: import("vitest").Mock<any, any>;
+        nsfw: boolean;
+        send: import("vitest").Mock<any, any>;
+        permissionsFor: import("vitest").Mock<any, any>;
+    };
+    member: {
+        id: string;
+        user: {
+            id: string;
+            username: string;
+        };
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        permissions: {
+            has: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    user: {
+        id: string;
+        username: string;
+    };
+    reply: import("vitest").Mock<any, any>;
+    deferReply: import("vitest").Mock<any, any>;
+    deferUpdate: import("vitest").Mock<any, any>;
+    update: import("vitest").Mock<any, any>;
+};
+export declare function createMockModalSubmitInteraction(overrides?: Record<string, any>): {
+    id: string;
+    customId: string;
+    fields: {
+        getTextInputValue: import("vitest").Mock<any, any>;
+        getField: import("vitest").Mock<any, any>;
+        fields: any[];
+    };
+    guild: {
+        id: string;
+        name: string;
+        ownerId: string;
+        channels: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        members: {
+            cache: Map<any, any>;
+            fetch: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    guildId: string;
+    channel: {
+        id: string;
+        type: number;
+        name: string;
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        isTextBased: import("vitest").Mock<any, any>;
+        isDMBased: import("vitest").Mock<any, any>;
+        nsfw: boolean;
+        send: import("vitest").Mock<any, any>;
+        permissionsFor: import("vitest").Mock<any, any>;
+    };
+    member: {
+        id: string;
+        user: {
+            id: string;
+            username: string;
+        };
+        guild: {
+            id: string;
+            name: string;
+            ownerId: string;
+            channels: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            members: {
+                cache: Map<any, any>;
+                fetch: import("vitest").Mock<any, any>;
+            };
+            roles: {
+                cache: Map<any, any>;
+            };
+        };
+        permissions: {
+            has: import("vitest").Mock<any, any>;
+        };
+        roles: {
+            cache: Map<any, any>;
+        };
+    };
+    user: {
+        id: string;
+        username: string;
+    };
+    reply: import("vitest").Mock<any, any>;
+    deferReply: import("vitest").Mock<any, any>;
+    deferUpdate: import("vitest").Mock<any, any>;
+};

package/dist/testing/mocks/discord.js

@@ -0,0 +1,183 @@
+import { vi } from 'vitest';
+export function createMockClient(overrides = {}) {
+    const listeners = {};
+    return {
+        on: vi.fn((event, cb) => {
+            if (!listeners[event])
+                listeners[event] = [];
+            listeners[event].push(cb);
+        }),
+        once: vi.fn((event, cb) => {
+            if (!listeners[event])
+                listeners[event] = [];
+            listeners[event].push(cb);
+        }),
+        emit: vi.fn((event, ...args) => {
+            if (listeners[event]) {
+                listeners[event].forEach((cb) => cb(...args));
+            }
+        }),
+        login: vi.fn().mockResolvedValue('token'),
+        destroy: vi.fn(),
+        guilds: {
+            cache: new Map(),
+            fetch: vi.fn(),
+        },
+        channels: {
+            cache: new Map(),
+            fetch: vi.fn(),
+        },
+        user: { id: '123456789', tag: 'TestBot#0000', username: 'TestBot' },
+        users: {
+            fetch: vi.fn(),
+        },
+        options: {},
+        ...overrides,
+        _listeners: listeners,
+    };
+}
+export function createMockGuild(overrides = {}) {
+    return {
+        id: 'guild-123',
+        name: 'Test Guild',
+        ownerId: 'owner-123',
+        channels: {
+            cache: new Map(),
+            fetch: vi.fn(),
+        },
+        members: {
+            cache: new Map(),
+            fetch: vi.fn(),
+        },
+        roles: {
+            cache: new Map(),
+        },
+        ...overrides,
+    };
+}
+export function createMockTextChannel(overrides = {}) {
+    return {
+        id: 'channel-123',
+        type: 0,
+        name: 'general',
+        guild: createMockGuild(),
+        isTextBased: vi.fn().mockReturnValue(true),
+        isDMBased: vi.fn().mockReturnValue(false),
+        nsfw: false,
+        send: vi.fn().mockResolvedValue({}),
+        permissionsFor: vi.fn().mockReturnValue({
+            has: vi.fn().mockReturnValue(true),
+        }),
+        ...overrides,
+    };
+}
+export function createMockGuildMember(overrides = {}) {
+    return {
+        id: 'member-123',
+        user: { id: 'user-123', username: 'TestUser' },
+        guild: createMockGuild(),
+        permissions: {
+            has: vi.fn().mockReturnValue(true),
+        },
+        roles: {
+            cache: new Map(),
+        },
+        ...overrides,
+    };
+}
+export function createMockMessage(overrides = {}) {
+    return {
+        id: 'message-123',
+        content: '!ping',
+        author: createMockGuildMember(),
+        channel: createMockTextChannel(),
+        guild: createMockGuild(),
+        guildId: 'guild-123',
+        member: createMockGuildMember(),
+        reply: vi.fn().mockResolvedValue({}),
+        delete: vi.fn().mockResolvedValue({}),
+        react: vi.fn().mockResolvedValue({}),
+        editable: true,
+        deletable: true,
+        ...overrides,
+    };
+}
+export function createMockCommandInteraction(overrides = {}) {
+    return {
+        id: 'interaction-123',
+        commandName: 'test',
+        guild: createMockGuild(),
+        guildId: 'guild-123',
+        channel: createMockTextChannel(),
+        member: createMockGuildMember(),
+        user: { id: 'user-123', username: 'TestUser' },
+        reply: vi.fn().mockResolvedValue({}),
+        deferReply: vi.fn().mockResolvedValue({}),
+        editReply: vi.fn().mockResolvedValue({}),
+        followUp: vi.fn().mockResolvedValue({}),
+        options: {
+            get: vi.fn(),
+            getString: vi.fn(),
+            getInteger: vi.fn(),
+            getBoolean: vi.fn(),
+            getUser: vi.fn(),
+            getChannel: vi.fn(),
+            getRole: vi.fn(),
+            getSubcommand: vi.fn(),
+        },
+        ...overrides,
+    };
+}
+export function createMockButtonInteraction(overrides = {}) {
+    return {
+        id: 'button-123',
+        customId: 'test-button',
+        guild: createMockGuild(),
+        guildId: 'guild-123',
+        channel: createMockTextChannel(),
+        member: createMockGuildMember(),
+        user: { id: 'user-123', username: 'TestUser' },
+        reply: vi.fn().mockResolvedValue({}),
+        deferReply: vi.fn().mockResolvedValue({}),
+        deferUpdate: vi.fn().mockResolvedValue({}),
+        update: vi.fn().mockResolvedValue({}),
+        ...overrides,
+    };
+}
+export function createMockStringSelectMenuInteraction(overrides = {}) {
+    return {
+        id: 'select-123',
+        customId: 'test-select',
+        values: ['option-1'],
+        guild: createMockGuild(),
+        guildId: 'guild-123',
+        channel: createMockTextChannel(),
+        member: createMockGuildMember(),
+        user: { id: 'user-123', username: 'TestUser' },
+        reply: vi.fn().mockResolvedValue({}),
+        deferReply: vi.fn().mockResolvedValue({}),
+        deferUpdate: vi.fn().mockResolvedValue({}),
+        update: vi.fn().mockResolvedValue({}),
+        ...overrides,
+    };
+}
+export function createMockModalSubmitInteraction(overrides = {}) {
+    return {
+        id: 'modal-123',
+        customId: 'test-modal',
+        fields: {
+            getTextInputValue: vi.fn().mockReturnValue(''),
+            getField: vi.fn(),
+            fields: [],
+        },
+        guild: createMockGuild(),
+        guildId: 'guild-123',
+        channel: createMockTextChannel(),
+        member: createMockGuildMember(),
+        user: { id: 'user-123', username: 'TestUser' },
+        reply: vi.fn().mockResolvedValue({}),
+        deferReply: vi.fn().mockResolvedValue({}),
+        deferUpdate: vi.fn().mockResolvedValue({}),
+        ...overrides,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
     "/baseModule"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "build": "tsc",
     "build-watch": "tsc -w",
     "lint": "eslint .",
@@ -47,17 +48,20 @@
     "@types/node": "^18.19.44",
     "@typescript-eslint/eslint-plugin": "^5.48.2",
     "@typescript-eslint/parser": "^5.48.2",
+    "@vitest/coverage-v8": "^1.6.1",
     "eslint": "^8.32.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-check-file": "^2.2.0",
     "eslint-plugin-prettier": "^4.2.1",
     "prettier": "^2.8.3",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^1.6.1"
   },
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
-    "./discord": "./dist/discord/index.js"
+    "./discord": "./dist/discord/index.js",
+    "./testing": "./dist/testing/index.js"
   },
   "typesVersions": {
     "*": {
@@ -66,6 +70,9 @@
       ],
       "discord": [
         "dist/discord/index.d.ts"
+      ],
+      "testing": [
+        "dist/testing/index.d.ts"
       ]
     }
   },