meocord 1.8.3 → 1.8.4

package/dist/esm/testing/mock-fn.js

@@ -0,0 +1,196 @@
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */ // ---------------------------------------------------------------------------
+// Framework-agnostic mock function
+//
+// A minimal mock-fn implementation used internally by the testing utilities so
+// that `meocord/testing` does not depend on jest OR vitest. Both jest and
+// vitest detect a mock via the `_isMockFunction` flag, and both
+// `expect(fn).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` read
+// `fn.mock.calls` — so a mock produced here is recognized by assertions in
+// either framework.
+// ---------------------------------------------------------------------------
+/**
+ * Type guard that recognises mocks produced by `createMockFn` as well as
+ * native `jest.fn()` / `vi.fn()` mocks — all stamp `_isMockFunction = true`.
+ */ function isMockFunction(fn) {
+    return typeof fn === 'function' && '_isMockFunction' in fn && fn._isMockFunction === true;
+}
+/**
+ * Creates a framework-agnostic mock function. Callable; records calls on
+ * `.mock.calls`; supports the mock-return/resolved/rejected/implementation
+ * API used by the testing utilities and by user assertions.
+ *
+ * @example
+ * const fn = createMockFn<(x: number) => number>((x) => x + 1)
+ * fn(2)                    // → 3
+ * fn.mockReturnValue(99)
+ * fn(2)                    // → 99
+ * fn.mock.calls             // → [[2], [2]]
+ */ function createMockFn(impl) {
+    let currentImpl = impl;
+    let returnOnce = [];
+    let returnValue = {
+        set: false,
+        value: undefined
+    };
+    let resolvedOnce = [];
+    let resolvedValue = {
+        set: false,
+        value: undefined
+    };
+    let rejectedOnce = [];
+    let rejectedValue = {
+        set: false,
+        value: undefined
+    };
+    const implOnce = [];
+    let name = 'vi.fn';
+    const calls = [];
+    const results = [];
+    const instances = [];
+    const mockFn = function(...args) {
+        calls.push(args);
+        instances.push(this);
+        let type = 'return';
+        let value;
+        try {
+            if (implOnce.length > 0) {
+                value = implOnce.shift().apply(this, args);
+            } else if (returnOnce.length > 0) {
+                value = returnOnce.shift();
+            } else if (returnValue.set) {
+                value = returnValue.value;
+            } else if (resolvedOnce.length > 0) {
+                value = Promise.resolve(resolvedOnce.shift());
+            } else if (resolvedValue.set) {
+                value = Promise.resolve(resolvedValue.value);
+            } else if (rejectedOnce.length > 0) {
+                value = Promise.reject(rejectedOnce.shift());
+            } else if (rejectedValue.set) {
+                value = Promise.reject(rejectedValue.value);
+            } else if (currentImpl !== undefined) {
+                value = currentImpl.apply(this, args);
+            } else {
+                value = undefined;
+            }
+            return value;
+        } catch (err) {
+            type = 'throw';
+            value = err;
+            throw err;
+        } finally{
+            results.push({
+                type,
+                value
+            });
+        }
+    };
+    // Stamp the marker both jest and vitest check via isMockFunction.
+    Object.defineProperty(mockFn, '_isMockFunction', {
+        value: true,
+        enumerable: false
+    });
+    const mock = {
+        get calls () {
+            return calls;
+        },
+        get results () {
+            return results;
+        },
+        get instances () {
+            return instances;
+        },
+        get lastCall () {
+            return calls.length > 0 ? calls[calls.length - 1] : undefined;
+        }
+    };
+    Object.defineProperty(mockFn, 'mock', {
+        value: mock,
+        enumerable: false
+    });
+    mockFn.mockReturnValue = (v)=>{
+        returnValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockReturnValueOnce = (v)=>{
+        returnOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockResolvedValue = (v)=>{
+        resolvedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockResolvedValueOnce = (v)=>{
+        resolvedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockRejectedValue = (v)=>{
+        rejectedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockRejectedValueOnce = (v)=>{
+        rejectedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockImplementation = (fn)=>{
+        currentImpl = fn;
+        return mockFn;
+    };
+    mockFn.mockImplementationOnce = (fn)=>{
+        implOnce.push(fn);
+        return mockFn;
+    };
+    mockFn.mockClear = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        return mockFn;
+    };
+    mockFn.mockReset = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        returnOnce = [];
+        returnValue = {
+            set: false,
+            value: undefined
+        };
+        resolvedOnce = [];
+        resolvedValue = {
+            set: false,
+            value: undefined
+        };
+        rejectedOnce = [];
+        rejectedValue = {
+            set: false,
+            value: undefined
+        };
+        implOnce.length = 0;
+        currentImpl = impl;
+        return mockFn;
+    };
+    mockFn.mockRestore = ()=>{
+        mockFn.mockReset();
+        return mockFn;
+    };
+    mockFn.getMockName = ()=>name;
+    mockFn.mockName = (n)=>{
+        name = n;
+        return mockFn;
+    };
+    return mockFn;
+}
+
+export { createMockFn, isMockFunction };

package/dist/esm/testing/mock-interaction.js

@@ -1,9 +1,9 @@
 import 'reflect-metadata';
-import { jest } from '@jest/globals';
+import { createMockFn } from './mock-fn.js';
 import { InteractionType, ComponentType, ApplicationCommandType, CommandInteractionOptionResolver, GuildMessageManager, ThreadManager, DMMessageManager, MessageManager, ThreadMemberManager, Client, ApplicationCommandManager, UserManager, ChannelManager, GuildManager, ClientUser, Guild, GuildMemberManager, GuildChannelManager, RoleManager, GuildBanManager, Message, User, GuildMember, TextChannel, ThreadChannel, MessageMentions } from 'discord.js';
 
 // ---------------------------------------------------------------------------
-// stubDeep — Proxy that auto-creates jest.fn() on any property access
+// stubDeep — Proxy that auto-creates a mock fn on any property access
 // ---------------------------------------------------------------------------
 const SKIP = new Set([
     'constructor',
@@ -21,7 +21,7 @@ function stubDeep(instance, externalStubs) {
                 return Reflect.get(target, prop, target);
             }
             const key = prop;
-            // 'then' must be undefined — prevents jest treating the mock as a Promise
+            // 'then' must be undefined — prevents frameworks treating the mock as a Promise
             if (key === 'then') return undefined;
             // Own property writes take precedence (e.g. interaction.guildId = 'abc')
             if (Object.prototype.hasOwnProperty.call(target, key)) {
@@ -44,7 +44,7 @@ function stubDeep(instance, externalStubs) {
                 }
                 proto = Object.getPrototypeOf(proto);
             }
-            const stub = typeof protoValue === 'function' ? jest.fn() : stubDeep({});
+            const stub = typeof protoValue === 'function' ? createMockFn() : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -114,7 +114,7 @@ const CLASS_TYPE_FIELDS = {
     }
 };
 // All known pure type-guard methods on BaseInteraction and its subclasses.
-// These are wired as jest.fn() wrapping the real prototype logic so they return
+// These are wired as a mock fn wrapping the real prototype logic so they return
 // correct values by default and can still be overridden per test.
 const TYPE_GUARD_METHODS = [
     'isCommand',
@@ -154,14 +154,14 @@ function findPrototypeMethod(instance, name) {
  *
  * **Type guards** (`isButton()`, `isRepliable()`, etc.) run the real discord.js
  * prototype logic — no manual `.mockReturnValue(true)` setup needed. They are
- * still `jest.fn()` so you can override them per test.
+ * still mock functions so you can override them per test.
  *
  * **Reply state machine** — `replied` and `deferred` start as `false`. Calling
  * `reply()` or `deferReply()` twice throws, just like a real interaction would.
  * `followUp()`, `editReply()`, and `deleteReply()` throw if called before any
- * reply. These are still `jest.fn()` so call assertions work normally.
+ * reply. These are still mock functions so call assertions work normally.
  *
- * All other methods are auto-stubbed as `jest.fn()` via Proxy.
+ * All other methods are auto-stubbed as a mock fn via Proxy.
  *
  * @example
  * ```ts
@@ -184,12 +184,12 @@ function findPrototypeMethod(instance, name) {
             instance[key] = value;
         }
     }
-    // Wire each type guard as jest.fn() calling the real prototype implementation.
+    // Wire each type guard as a mock fn calling the real prototype implementation.
     // Correct by default; overridable per test via .mockReturnValue().
     for (const name of TYPE_GUARD_METHODS){
         const method = findPrototypeMethod(instance, name);
         if (method !== null) {
-            stubs.set(name, jest.fn().mockImplementation(()=>method.call(instance)));
+            stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
         }
     }
     // Set up reply state machine for repliable interactions
@@ -209,36 +209,36 @@ function findPrototypeMethod(instance, name) {
             if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
             return false;
         };
-        stubs.set('reply', jest.fn(async (...args)=>{
+        stubs.set('reply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.replied = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('deferReply', jest.fn(async (...args)=>{
+        stubs.set('deferReply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.deferred = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('followUp', jest.fn(async ()=>{
+        stubs.set('followUp', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('editReply', jest.fn(async ()=>{
+        stubs.set('editReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('deleteReply', jest.fn(async ()=>{
+        stubs.set('deleteReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
         }));
         // deferUpdate / update — MessageComponentInteraction only (type === MessageComponent)
         if (instance.type === InteractionType.MessageComponent) {
-            stubs.set('update', jest.fn(async ()=>{
+            stubs.set('update', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
             }));
-            stubs.set('deferUpdate', jest.fn(async ()=>{
+            stubs.set('deferUpdate', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.deferred = true;
             }));
@@ -249,18 +249,18 @@ function findPrototypeMethod(instance, name) {
 // ---------------------------------------------------------------------------
 // Convenience wrappers for common discord.js classes
 // ---------------------------------------------------------------------------
-/** Creates a mock {@link User}. All methods are auto-stubbed as `jest.fn()`. */ const createMockUser = ()=>createMockInteraction(User);
+/** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */ const createMockUser = ()=>createMockInteraction(User);
 /**
  * Creates a mock {@link Client}.
  *
  * Manager methods that are constructor-assigned (not on the prototype) are
- * pre-initialized as `jest.fn()` so they work out of the box without manual
+ * pre-initialized as a mock fn so they work out of the box without manual
  * setup: `users.fetch`, `channels.fetch`, `guilds.fetch`, and
  * `application.commands.fetch`.
  */ function createMockClient() {
     const instance = Object.create(Client.prototype);
     // Manager properties are constructor-assigned — pre-initialize as prototype-based
-    // stubs so ALL manager methods (not just fetch) are auto-stubbed as jest.fn().
+    // stubs so ALL manager methods (not just fetch) are auto-stubbed as a mock fn.
     const appInstance = Object.create(null);
     appInstance.commands = stubDeep(Object.create(ApplicationCommandManager.prototype));
     instance.users = stubDeep(Object.create(UserManager.prototype));
@@ -275,7 +275,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties are constructor-assigned in discord.js. This factory
  * pre-initializes each as a prototype-based stub so all methods are
- * auto-stubbed as `jest.fn()`.
+ * auto-stubbed as a mock fn.
  *
  * Pre-initialized: `members`, `channels`, `roles`, `bans`.
  */ function createMockGuild() {
@@ -291,7 +291,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties that are constructor-assigned in discord.js are
  * pre-initialized as prototype-based stubs so all methods are auto-stubbed
- * as `jest.fn()`:
+ * as a mock fn:
  * - Guild text channels (`TextChannel`, `NewsChannel`): `messages`, `threads`
  * - `DMChannel`: `messages`
  * - `ThreadChannel`: `messages`, `members`
@@ -326,7 +326,7 @@ function findPrototypeMethod(instance, name) {
  * `msg.channel.send`, `msg.guild.members.fetch`, `msg.thread.fetch`,
  * and `msg.mentions.has` all work out of the box.
  *
- * All methods remain `jest.fn()` — overridable per test.
+ * All methods remain mock functions — overridable per test.
  *
  * Note: `createMockInteraction`'s `followUp()` and `editReply()` stubs return
  * a `createMockMessage()` by default, matching the official return types.
@@ -349,7 +349,7 @@ function createMockMessage() {
     // Constructor-assigned — set as prototype-based stubs
     instance.author = stubDeep(Object.create(User.prototype));
     // Getters on the prototype — the proxy sees them as functions and returns
-    // jest.fn(), which is wrong. Pre-initialize as own properties to shadow
+    // a mock fn, which is wrong. Pre-initialize as own properties to shadow
     // the prototype getters.
     Object.defineProperty(instance, 'member', {
         value: stubDeep(Object.create(GuildMember.prototype)),
@@ -370,25 +370,25 @@ function createMockMessage() {
     // MessageMentions — constructor-assigned, has methods like .has(), .members
     instance.mentions = stubDeep(Object.create(MessageMentions.prototype));
     const alreadyDeleted = ()=>new Error('This message has already been deleted.');
-    stubs.set('delete', jest.fn(async ()=>{
+    stubs.set('delete', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         instance.deleted = true;
     }));
-    stubs.set('edit', jest.fn(async ()=>{
+    stubs.set('edit', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('reply', jest.fn(async ()=>{
+    stubs.set('reply', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('react', jest.fn(async ()=>{
+    stubs.set('react', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('pin', jest.fn(async ()=>{
+    stubs.set('pin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('unpin', jest.fn(async ()=>{
+    stubs.set('unpin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
     return stubDeep(instance, stubs);
@@ -398,7 +398,7 @@ function createMockMessage() {
  * `CommandInteractionOptionResolver` works: declare what options the command
  * was invoked with, and the resolver finds them by name.
  *
- * All explicit methods are `jest.fn()` — override per test with `.mockReturnValue()`.
+ * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
  * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
  *
  * @example
@@ -430,20 +430,20 @@ function createMockMessage() {
     }
     const isObjectOption = (v)=>typeof v === 'object' && v !== null && 'id' in v;
     // Use a real prototype instance so unlisted methods (e.g. getAttachment)
-    // are found on the prototype chain and auto-stubbed as jest.fn()
+    // are found on the prototype chain and auto-stubbed as a mock fn
     const base = Object.create(CommandInteractionOptionResolver.prototype);
-    base.getSubcommandGroup = jest.fn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
-    base.getSubcommand = jest.fn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
-    base.getString = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
-    base.getNumber = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getInteger = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getBoolean = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
+    base.getSubcommandGroup = createMockFn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
+    base.getSubcommand = createMockFn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
+    base.getString = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
+    base.getNumber = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getInteger = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getBoolean = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
     const getObjectOption = (name, required)=>resolveOrThrow(name, isObjectOption(values[name]) ? values[name] : null, required);
-    base.getUser = jest.fn(getObjectOption);
-    base.getRole = jest.fn(getObjectOption);
-    base.getChannel = jest.fn(getObjectOption);
-    base.getMember = jest.fn(getObjectOption);
-    base.getMentionable = jest.fn(getObjectOption);
+    base.getUser = createMockFn(getObjectOption);
+    base.getRole = createMockFn(getObjectOption);
+    base.getChannel = createMockFn(getObjectOption);
+    base.getMember = createMockFn(getObjectOption);
+    base.getMentionable = createMockFn(getObjectOption);
     return stubDeep(base);
 }
 

package/dist/types/testing/index.d.ts

@@ -1,6 +1,5 @@
 import { ServiceIdentifier, Container } from 'inversify';
 import { GuardInterface } from '../interface/index.js';
-import { jest } from '@jest/globals';
 import { CommandInteractionOptionResolver, Channel, Client, Guild, Message, User } from 'discord.js';
 import 'webpack';
 import '../controller.enum-QA-IuReF.js';
@@ -54,10 +53,12 @@ declare class TestingModuleBuilder {
  *
  * @example
  * ```typescript
+ * import { MeoCordTestingModule, createMockFn } from 'meocord/testing'
+ *
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: jest.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: createMockFn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *
@@ -68,6 +69,70 @@ declare class MeoCordTestingModule {
     static create(options: TestingModuleOptions): TestingModuleBuilder;
 }
 
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */
+interface MockResult<T = unknown> {
+    type: 'return' | 'throw';
+    value: T;
+}
+interface MockState<T extends (...args: any[]) => any = (...args: any[]) => any> {
+    /** Arguments from each call, in order. */
+    readonly calls: Parameters<T>[];
+    /** Return / throw result from each call, in order. */
+    readonly results: MockResult<ReturnType<T>>[];
+    /** The `this` value recorded for each call. */
+    readonly instances: any[];
+    /** Arguments from the most recent call, or undefined if never called. */
+    readonly lastCall?: Parameters<T>;
+}
+interface MockInstance<T extends (...args: any[]) => any = (...args: any[]) => any> {
+    /** Marker both jest and vitest check via `isMockFunction`. Do not remove. */
+    readonly _isMockFunction: true;
+    readonly mock: MockState<T>;
+    mockReturnValue(value: ReturnType<T>): MockedFunction<T>;
+    mockReturnValueOnce(value: ReturnType<T>): MockedFunction<T>;
+    mockResolvedValue(value: Awaited<ReturnType<T>>): MockedFunction<T>;
+    mockResolvedValueOnce(value: Awaited<ReturnType<T>>): MockedFunction<T>;
+    mockRejectedValue(value: unknown): MockedFunction<T>;
+    mockRejectedValueOnce(value: unknown): MockedFunction<T>;
+    mockImplementation(fn: T): MockedFunction<T>;
+    mockImplementationOnce(fn: T): MockedFunction<T>;
+    mockClear(): MockedFunction<T>;
+    mockReset(): MockedFunction<T>;
+    mockRestore(): MockedFunction<T>;
+    getMockName(): string;
+    mockName(name: string): MockedFunction<T>;
+}
+/**
+ * A callable that mirrors the signature of `T` and exposes the mock API
+ * (`mockReturnValue`, `mockResolvedValue`, `mockImplementation`, `.mock`, …).
+ * Drop-in replacement for `jest.MockedFunction<T>` / vitest `MockedFunction<T>`.
+ */
+type MockedFunction<T extends (...args: any[]) => any> = ((...args: Parameters<T>) => ReturnType<T>) & MockInstance<T>;
+/** Alias kept for parity with `jest.Mock` / vitest `Mock`. */
+type Mock<T extends (...args: any[]) => any = (...args: any[]) => any> = MockedFunction<T>;
+/**
+ * Type guard that recognises mocks produced by `createMockFn` as well as
+ * native `jest.fn()` / `vi.fn()` mocks — all stamp `_isMockFunction = true`.
+ */
+declare function isMockFunction(fn: unknown): fn is MockInstance;
+/**
+ * Creates a framework-agnostic mock function. Callable; records calls on
+ * `.mock.calls`; supports the mock-return/resolved/rejected/implementation
+ * API used by the testing utilities and by user assertions.
+ *
+ * @example
+ * const fn = createMockFn<(x: number) => number>((x) => x + 1)
+ * fn(2)                    // → 3
+ * fn.mockReturnValue(99)
+ * fn(2)                    // → 99
+ * fn.mock.calls             // → [[2], [2]]
+ */
+declare function createMockFn<T extends (...args: any[]) => any = (...args: any[]) => any>(impl?: T): MockedFunction<T>;
+
 /**
  * MeoCord Framework
  * Copyright (c) 2025 Ukasyah Rahmatullah Zada
@@ -75,13 +140,13 @@ declare class MeoCordTestingModule {
  */
 
 /**
- * Recursively transforms all methods of T into jest.MockedFunction and all
+ * Recursively transforms all methods of T into MockedFunction and all
  * nested objects into DeepMocked. Depth cap at 5 prevents infinite recursion
  * on circular discord.js types (e.g. Guild ↔ GuildMember).
  * -readonly removes readonly modifiers so test setup can write any property.
  */
 type DeepMocked<T, Depth extends number[] = []> = Depth['length'] extends 5 ? T : {
-    -readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? jest.MockedFunction<(...args: A) => R> : T[K] extends object ? DeepMocked<T[K], [...Depth, 0]> : T[K];
+    -readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? MockedFunction<(...args: A) => R> : T[K] extends object ? DeepMocked<T[K], [...Depth, 0]> : T[K];
 };
 interface InteractionClass<T> {
     prototype: T;
@@ -93,14 +158,14 @@ interface InteractionClass<T> {
  *
  * **Type guards** (`isButton()`, `isRepliable()`, etc.) run the real discord.js
  * prototype logic — no manual `.mockReturnValue(true)` setup needed. They are
- * still `jest.fn()` so you can override them per test.
+ * still mock functions so you can override them per test.
  *
  * **Reply state machine** — `replied` and `deferred` start as `false`. Calling
  * `reply()` or `deferReply()` twice throws, just like a real interaction would.
  * `followUp()`, `editReply()`, and `deleteReply()` throw if called before any
- * reply. These are still `jest.fn()` so call assertions work normally.
+ * reply. These are still mock functions so call assertions work normally.
  *
- * All other methods are auto-stubbed as `jest.fn()` via Proxy.
+ * All other methods are auto-stubbed as a mock fn via Proxy.
  *
  * @example
  * ```ts
@@ -115,13 +180,13 @@ interface InteractionClass<T> {
  * ```
  */
 declare function createMockInteraction<T extends object>(Class: InteractionClass<T>): DeepMocked<T>;
-/** Creates a mock {@link User}. All methods are auto-stubbed as `jest.fn()`. */
+/** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */
 declare const createMockUser: () => DeepMocked<User>;
 /**
  * Creates a mock {@link Client}.
  *
  * Manager methods that are constructor-assigned (not on the prototype) are
- * pre-initialized as `jest.fn()` so they work out of the box without manual
+ * pre-initialized as a mock fn so they work out of the box without manual
  * setup: `users.fetch`, `channels.fetch`, `guilds.fetch`, and
  * `application.commands.fetch`.
  */
@@ -131,7 +196,7 @@ declare function createMockClient(): DeepMocked<Client>;
  *
  * Manager properties are constructor-assigned in discord.js. This factory
  * pre-initializes each as a prototype-based stub so all methods are
- * auto-stubbed as `jest.fn()`.
+ * auto-stubbed as a mock fn.
  *
  * Pre-initialized: `members`, `channels`, `roles`, `bans`.
  */
@@ -141,7 +206,7 @@ declare function createMockGuild(): DeepMocked<Guild>;
  *
  * Manager properties that are constructor-assigned in discord.js are
  * pre-initialized as prototype-based stubs so all methods are auto-stubbed
- * as `jest.fn()`:
+ * as a mock fn:
  * - Guild text channels (`TextChannel`, `NewsChannel`): `messages`, `threads`
  * - `DMChannel`: `messages`
  * - `ThreadChannel`: `messages`, `members`
@@ -160,7 +225,7 @@ interface ChatInputOptions {
  * `CommandInteractionOptionResolver` works: declare what options the command
  * was invoked with, and the resolver finds them by name.
  *
- * All explicit methods are `jest.fn()` — override per test with `.mockReturnValue()`.
+ * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
  * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
  *
  * @example
@@ -177,5 +242,5 @@ interface ChatInputOptions {
  */
 declare function createChatInputOptions(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver>;
 
-export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMessage, createMockUser };
-export type { ChatInputOptions, ClassProvider, DeepMocked, Provider, TestingModuleOptions, ValueProvider };
+export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };
+export type { ChatInputOptions, ClassProvider, DeepMocked, Mock, MockInstance, MockResult, MockState, MockedFunction, Provider, TestingModuleOptions, ValueProvider };

package/meocord.eslint.cjs

@@ -83,7 +83,7 @@ const specConfig = {
 }
 
 module.exports = [
-  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'jest.config.ts'] },
+  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'vitest.config.ts'] },
   ...recommendedTypeScriptConfigs,
   specConfig,
   eslintConfigPrettier,

package/meocord.eslint.mjs

@@ -83,7 +83,7 @@ const specConfig = {
 }
 
 export default [
-  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'jest.config.ts'] },
+  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'vitest.config.ts'] },
   ...recommendedTypeScriptConfigs,
   specConfig,
   eslintConfigPrettier,