vitest-auto-spy 1.2.0 → 1.4.0

package/README.md

@@ -2,10 +2,13 @@
 
 # vitest-auto-spy
 
-**Automatic, fully-typed test spies from a class — powered by Vitest's `vi.fn()`.**
+**Auto-generate fully-typed test spies from a class — across any Vitest-compatible runtime and framework.**
 
-A drop-in replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spies):
-same API, but spying only on **Vitest** instead of Jest.
+The only auto-spy library that reads a **class** and gives a **fully-typed** spy of every method
+with **return-type-aware** helpers (`resolveWith` / `nextWith` / `calledWith`). Available today for
+**Vitest** (with **RxJS** and **Angular** helpers); **Bun**, **node:test**, and NestJS / React /
+Vue·Pinia / Svelte recipes land in the next release ([availability](#availability)). A drop-in
+replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spies) — same API.
 
 [![npm version](https://img.shields.io/npm/v/vitest-auto-spy?color=cb3837&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![npm downloads](https://img.shields.io/npm/dm/vitest-auto-spy?color=cb3837&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
@@ -15,33 +18,53 @@ same API, but spying only on **Vitest** instead of Jest.
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
 
+[![Vitest](https://img.shields.io/badge/Vitest-✓-6E9F18?logo=vitest&logoColor=white)](#runtimes)
+[![Bun](https://img.shields.io/badge/Bun-next-yellow?logo=bun&logoColor=white)](#availability)
+[![node:test](https://img.shields.io/badge/node%3Atest-next-yellow?logo=node.js&logoColor=white)](#availability)
+[![runtime deps](https://img.shields.io/badge/runtime%20deps-0-brightgreen)](#install)
+
 📦 [**npm**](https://www.npmjs.com/package/vitest-auto-spy) · 🐙 [**GitHub**](https://github.com/ASDAlexey/vitest-auto-spy) · 🔖 [**Changelog**](./CHANGELOG.md)
 
 </div>
 
 ---
 
-- 🧪 Reads a class and generates a typed `vi.fn()` spy for **every** method
+- 🧪 Reads a class and generates a typed spy for **every** method — no hand-written `vi.fn()` lists
+- 🧬 Or mock from a **type/interface** alone — `createAutoMock<T>()`, no class required
+- 🌐 One `MockAdapter` core — **Vitest** today; **Bun** and **`node:test`** next release, identical API on each
+- 🧩 Framework recipes: **Angular** today; **NestJS, React, Vue/Pinia, Svelte** next release
 - 🎯 Return-type-aware helpers — sync, `Promise`, and `Observable` all get the right API
 - 🔀 `calledWith` / `mustBeCalledWith` argument dispatch
 - 📡 First-class RxJS `Observable` spying (`nextWith`, `nextWithValues`, `throwWith`, …)
 - ⚙️ Getter / setter spies via `accessorSpies`
-- 🅰️ Angular helpers (`provideAutoSpy`, `injectSpy`) — works with **both zoneless and zone.js**
-- 🟢 100% test coverage, zero runtime dependencies beyond a tiny arg serializer
+- 🟢 100% test coverage, **zero runtime dependencies** (in-tree arg serializer, no `javascript-stringify`)
 
 ## Table of contents
 
 - [Install](#install)
+- [Availability](#availability)
+- [Quick start](#quick-start)
 - [Why](#why)
+- [How it works (and what it won't spy)](#how-it-works-and-what-it-wont-spy)
+- [Comparison](#comparison)
 - [Migrating from jest-auto-spies](#migrating-from-jest-auto-spies)
 - [Configuration](#configuration)
+- [Auto-mock by type (no class needed)](#auto-mock-by-type-no-class-needed)
 - [Synchronous methods](#synchronous-methods)
 - [Promise-returning methods](#promise-returning-methods)
 - [Observable methods & properties](#observable-returning-methods--observable-properties)
 - [Getters & setters](#getters--setters)
-- [Angular helpers](#angular-helpers)
+- [Framework adapters](#framework-adapters)
+  - [NestJS](#nestjs)
+  - [React (Testing Library)](#react-testing-library)
+  - [Vue / Pinia](#vue--pinia)
+  - [Svelte](#svelte)
+  - [Angular](#angular)
 - [API reference](#api-reference)
+- [FAQ & troubleshooting](#faq--troubleshooting)
+- [Versioning](#versioning)
 - [Contributing](#contributing)
+- [Acknowledgements](#acknowledgements)
 - [License](#license)
 
 ## Install
@@ -50,33 +73,77 @@ same API, but spying only on **Vitest** instead of Jest.
 npm i -D vitest-auto-spy
 ```
 
-Peer dependencies are all **optional** and provided by your project: `vitest` (required),
-plus `rxjs` and `@angular/core` only if you use the matching entry point. The package itself
-has **zero runtime dependencies**.
+### Requirements
+
+| Tool | Minimum |
+| --- | --- |
+| Node.js | ≥ 18 |
+| Vitest | ≥ 1.0 (required peer) |
+| TypeScript | ≥ 4.7 for the typed helpers (plain JS works too, just untyped) |
 
-### Entry points
+Ships **dual ESM + CommonJS** with bundled `.d.ts` types, so it drops into both `import`- and
+`require`-style test setups.
 
-The library ships a framework-agnostic core and two opt-in layers, so a plain Node / Bun /
-React / Vue project pulls **neither rxjs nor Angular into its runtime bundle**:
+### Peer dependencies
 
-| Import | Provides | Pulls in |
+All peers are **provided by your project**; `rxjs` and `@angular/core` are **optional** — install
+them only for the matching entry point. The package itself has **zero runtime dependencies**.
+
+| Peer | Needed for | Optional? |
 | --- | --- | --- |
-| `vitest-auto-spy` | `createSpyFromClass`, `createFunctionSpy`, sync + promise + accessor spies, `errorHandler`, types | `vitest` |
-| `vitest-auto-spy/rxjs` | observable spies (`nextWith`, `nextWithValues`, `observablePropsToSpyOn`, …) + `createObservableWithValues` | `rxjs` |
-| `vitest-auto-spy/angular` | `provideAutoSpy`, `injectSpy`, `mockReadonlyProp*`, `mockAccessorsProp` | `@angular/core` |
+| `vitest` | the default runner | no |
+| `rxjs` | `vitest-auto-spy/rxjs` observable spies (and `Spy<T>` type-checking) | yes |
+| `@angular/core` | `vitest-auto-spy/angular` helpers | yes |
+
+## Availability
+
+> **On npm today vs. shipping next.** `vitest-auto-spy@1.3.0` publishes the **Vitest core** plus the
+> **RxJS** and **Angular** layers. The Bun / `node:test` runtimes and the NestJS / React / Vue /
+> Svelte recipes are implemented and tested in the repo but **not yet published as entry points** —
+> they land in the next release. Snippets that use them are marked _next release_ below.
+
+| Entry point | Status |
+| --- | --- |
+| `vitest-auto-spy` · `vitest-auto-spy/rxjs` · `vitest-auto-spy/angular` | ✅ **Published** (1.3.0) |
+| `vitest-auto-spy/bun` · `vitest-auto-spy/node` | 🔜 next release |
+| `vitest-auto-spy/nestjs` · `/react` · `/vue` · `/svelte` | 🔜 next release |
+
+## Quick start
+
+Pass a class — every method becomes a typed spy, and the **constructor is never called** (no side
+effects). The helper you get on each method matches its return type:
 
 ```ts
-import { createSpyFromClass } from 'vitest-auto-spy';
-import 'vitest-auto-spy/rxjs'; // once (e.g. in your test setup) — enables observable spies
-import { provideAutoSpy, injectSpy } from 'vitest-auto-spy/angular';
+import { beforeEach, expect, it } from 'vitest';
+import { createSpyFromClass, type Spy } from 'vitest-auto-spy';
+
+class UserService {
+  getName(id: number): string {
+    return 'real name';
+  }
+  async getUser(id: number): Promise<{ id: number; name: string }> {
+    return fetchUser(id);
+  }
+}
+
+let userService: Spy<UserService>;
+
+beforeEach(() => {
+  userService = createSpyFromClass(UserService); // every method is now a spy
+});
+
+it('stubs each method with the right helper for its return type', async () => {
+  userService.getName.mockReturnValue('Ada'); // sync
+  userService.getUser.resolveWith({ id: 1, name: 'Ada' }); // Promise helper
+
+  expect(userService.getName(1)).toBe('Ada');
+  await expect(userService.getUser(1)).resolves.toEqual({ id: 1, name: 'Ada' });
+  expect(userService.getName).toHaveBeenCalledWith(1);
+});
 ```
 
-> Using an observable spy (`observablePropsToSpyOn`, `nextWith`, …) without importing
-> `vitest-auto-spy/rxjs` throws a clear hint telling you to add that import.
->
-> The decoupling is at the **runtime** level. The core's _type_ surface (`Spy<T>`) still
-> references rxjs types, so keep `rxjs` available for type-checking (it's normally already a
-> devDependency); none of it reaches your runtime bundle.
+No class, only a TypeScript type? Reach for
+[`createAutoMock<T>()`](#auto-mock-by-type-no-class-needed).
 
 ## Why
 
@@ -105,6 +172,100 @@ beforeEach(() => {
 `Spy<UserService>` exposes each method as a `vi.fn()` **plus** the right helpers based on
 the method's return type (sync / `Promise` / `Observable`).
 
+## How it works (and what it won't spy)
+
+`createSpyFromClass(MyService)` reads `MyService.prototype` and walks the **prototype chain** — it
+never `new`s the class. Concretely:
+
+- ✅ **The class is never instantiated.** The constructor and its side effects (HTTP clients, DB
+  connections, `inject()` calls) never run — you pass the class itself, not an instance.
+- ✅ **Inherited methods are spied too**, all the way up the prototype chain.
+- ✅ Each method is replaced by a fresh spy carrying the helpers that match its **return type**:
+  sync → `mockReturnValue` / `calledWith`; `Promise` → `resolveWith` / `rejectWith`; `Observable`
+  → `nextWith` / `throwWith` / … .
+
+What it **won't** auto-discover — by design, because these aren't prototype methods:
+
+- ⚠️ **Arrow-function class fields** (`doThing = () => {}`) are instance properties set in the
+  constructor, so prototype scanning can't see them. Use regular methods, list them explicitly, or
+  mock them by hand. (Same constraint as `jest-auto-spies`.)
+- ⚠️ **Getters / setters** are skipped unless named in `gettersToSpyOn` / `settersToSpyOn` — see
+  [Getters & setters](#getters--setters).
+- ⚠️ **Plain data properties** carry no value until you set one; auto-spy mocks *behaviour*
+  (methods), not state. To mock by type including properties, use
+  [`createAutoMock`](#auto-mock-by-type-no-class-needed).
+
+## Entry points & runtimes
+
+The library ships a framework-agnostic core plus runtime and framework layers, so a plain
+Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runtime bundle**:
+
+| Import | Provides | Pulls in | Status |
+| --- | --- | --- | :---: |
+| `vitest-auto-spy` | `createSpyFromClass`, `createAutoMock`, `createFunctionSpy`, sync + promise + accessor spies, `errorHandler`, types | `vitest` | ✅ |
+| `vitest-auto-spy/rxjs` | observable spies (`nextWith`, `nextWithValues`, `observablePropsToSpyOn`, …) + `createObservableWithValues` | `rxjs` | ✅ |
+| `vitest-auto-spy/angular` | `provideAutoSpy`, `injectSpy`, `mockReadonlyProp*`, `mockAccessorsProp` | `@angular/core` | ✅ |
+| `vitest-auto-spy/bun` | the same core, driven by Bun's `bun:test` mocks | `bun:test` | 🔜 |
+| `vitest-auto-spy/node` | the same core, driven by `node:test`'s `mock.fn()` | `node:test` | 🔜 |
+| `vitest-auto-spy/nestjs` | `provideAutoSpy`, `injectSpy` for `Test.createTestingModule` | — (your `@nestjs/*`) | 🔜 |
+| `vitest-auto-spy/react` | the core, with a natural import for React Testing Library suites | — (your `react`) | 🔜 |
+| `vitest-auto-spy/vue` | `provideAutoSpy` for `global.provide` + Pinia store spying | — (your `vue`/`pinia`) | 🔜 |
+| `vitest-auto-spy/svelte` | the core, with a natural import for Svelte suites | — (your `svelte`) | 🔜 |
+
+✅ published in 1.3.0 · 🔜 next release (see [Availability](#availability)).
+
+> The framework subpaths import **nothing** from their framework — the helpers are structural, so
+> `@nestjs/*`, `react`, `vue`/`pinia` and `svelte` stay your own (already-present) dev dependencies and
+> never reach this package's runtime bundle.
+
+```ts
+import { createSpyFromClass } from 'vitest-auto-spy';
+import 'vitest-auto-spy/rxjs'; // once (e.g. in your test setup) — enables observable spies
+import { provideAutoSpy, injectSpy } from 'vitest-auto-spy/angular';
+```
+
+### Runtimes
+
+The core is runner-agnostic behind a `MockAdapter`: pick the entry that matches your test
+runner — the public API (`createSpyFromClass`, `calledWith`, `resolveWith`, `nextWith`, …) is
+identical across all three.
+
+```ts
+import { createSpyFromClass } from 'vitest-auto-spy'; // Vitest (default, zero-config)
+import { createSpyFromClass } from 'vitest-auto-spy/bun'; // Bun — bun:test  (next release)
+import { createSpyFromClass } from 'vitest-auto-spy/node'; // node:test      (next release)
+```
+
+> Only the auto-spy helpers are normalised across runtimes; **native** mock methods stay the
+> runner's own — `mockReturnValue` on Vitest/Bun, `spy.method.mock.mockImplementation` on
+> `node:test`. Each entry registers its adapter on import, so import the one matching your runner.
+
+> Using an observable spy (`observablePropsToSpyOn`, `nextWith`, …) without importing
+> `vitest-auto-spy/rxjs` throws a clear hint telling you to add that import.
+>
+> The decoupling is at the **runtime** level. The core's _type_ surface (`Spy<T>`) still
+> references rxjs types, so keep `rxjs` available for type-checking (it's normally already a
+> devDependency); none of it reaches your runtime bundle.
+>
+> The same inversion-of-control applies to the **test runner**: the core no longer imports
+> `vitest` directly — `vi.fn()` / `vi.spyOn()` sit behind a `MockAdapter` that the
+> `vitest-auto-spy` entry registers by default, so it stays zero-config. This is the groundwork
+> for running the exact same core on other Vitest-compatible runners.
+
+## Comparison
+
+| Library | Reads a class? | Return-type-aware helpers? | Runtimes | We win on |
+| --- | :---: | :---: | --- | --- |
+| **vitest-auto-spy** | ✅ | ✅ | Vitest (Bun · node:test next) | — |
+| [jest-auto-spies](https://www.npmjs.com/package/jest-auto-spies) | ✅ | ✅ | Jest only | Vitest/Bun/Node successor, **same API** — direct migration path |
+| [vitest-mock-extended](https://www.npmjs.com/package/vitest-mock-extended) | ❌ (Proxy) | ❌ | Vitest | Return-type ergonomics **and** reading a real class (we also ship a Proxy mode: [`createAutoMock`](#auto-mock-by-type-no-class-needed)) |
+| [@golevelup/ts-vitest](https://www.npmjs.com/package/@golevelup/ts-vitest) | partial | ❌ | Vitest | Typed `Promise`/`Observable` helpers + explicit class→spy + `mustBeCalledWith` |
+| [sinon](https://www.npmjs.com/package/sinon) | ❌ (manual) | ❌ | Any | Auto-generated + fully typed vs. manual + loosely typed |
+
+**The pitch:** the only auto-spy library that reads a **class** and gives a **fully-typed** spy of
+every method with **return-type-aware** control helpers (`resolveWith` / `nextWith` / `calledWith`) —
+across any Vitest-compatible runtime and framework.
+
 ## Migrating from jest-auto-spies
 
 The public API is intentionally identical. In most projects the migration is a
@@ -118,7 +279,7 @@ The public API is intentionally identical. In most projects the migration is a
 ```
 
 The only API-shape change from `jest-auto-spies` is that the Angular helpers and the
-observable layer live behind the `/angular` and `/rxjs` subpaths (see [Entry points](#entry-points)).
+observable layer live behind the `/angular` and `/rxjs` subpaths (see [Entry points & runtimes](#entry-points--runtimes)).
 
 | jest-auto-spies | vitest-auto-spy | Status |
 | --- | --- | --- |
@@ -152,6 +313,50 @@ createSpyFromClass(MyService, {
 });
 ```
 
+## Auto-mock by type (no class needed)
+
+`createSpyFromClass` reads a real class's prototype. When you only have a TypeScript **interface or
+type** (no runtime class), use `createAutoMock<T>()` — it builds the spy lazily from the type alone,
+via a `Proxy`:
+
+```ts
+import { createAutoMock } from 'vitest-auto-spy';
+
+interface UserService {
+  getName(id: number): string;
+  getUser(id: number): Promise<User>;
+  apiUrl: string;
+}
+
+// Before — needs a concrete class:
+// const svc = createSpyFromClass(UserServiceClass);
+
+// After — type only, no class:
+const svc = createAutoMock<UserService>();
+```
+
+Every accessed method becomes a decorated spy with the **same typed control helpers** as
+`createSpyFromClass`, materialized lazily and cached (same reference on re-access):
+
+```ts
+svc.getName.calledWith(1).mockReturnValue('Ada');   // sync, arg-matched
+svc.getUser.resolveWith({ id: 1, name: 'Ada' });    // promise helper
+expect(svc.getName(1)).toBe('Ada');
+await expect(svc.getUser(1)).resolves.toEqual({ id: 1, name: 'Ada' });
+```
+
+Seed concrete values or implementations with the optional `overrides` argument (seeded keys are
+returned as-is, never turned into spies):
+
+```ts
+const svc = createAutoMock<UserService>({ apiUrl: 'https://api.test' });
+expect(svc.apiUrl).toBe('https://api.test'); // or assign: svc.apiUrl = '...'
+```
+
+> Caveat: with only a type at runtime, methods and plain properties are indistinguishable on
+> access — an un-seeded property read returns a spy. Seed real property values via `overrides`
+> (or assignment) to get them back verbatim.
+
 ## Synchronous methods
 
 ```ts
@@ -246,7 +451,144 @@ spy.userName = 'New Name';
 expect(spy.accessorSpies.setters.userName).toHaveBeenCalledWith('New Name');
 ```
 
-## Angular helpers
+## Framework adapters
+
+The core is framework-agnostic — `createSpyFromClass` / `createAutoMock` work in any test. The
+subpaths below add a natural import and, where the framework has class DI, a tiny `provide*` helper.
+None of them pull the framework into this package; they're recipes over the same core.
+
+> **Angular** (`vitest-auto-spy/angular`) is published today. The **NestJS, React, Vue/Pinia and
+> Svelte** entry points ship in the next release ([Availability](#availability)) — until then you
+> can copy the recipe using the core `vitest-auto-spy` import directly.
+
+### NestJS
+
+Use `provideAutoSpy` to register a fully-mocked service in a `TestingModule`, then `injectSpy` to
+pull it back out already typed as `Spy<T>`. `@nestjs/common` / `@nestjs/testing` are your own
+(optional) peers — the helper imports neither:
+
+```ts
+import { Test, type TestingModule } from '@nestjs/testing';
+import { provideAutoSpy, injectSpy } from 'vitest-auto-spy/nestjs';
+import { beforeEach, expect, it } from 'vitest';
+
+import { AuthService } from './auth.service';
+import { UserService } from './user.service';
+
+let moduleRef: TestingModule;
+let userServiceSpy: Spy<UserService>;
+
+beforeEach(async () => {
+  moduleRef = await Test.createTestingModule({
+    providers: [AuthService, provideAutoSpy(UserService)],
+  }).compile();
+
+  userServiceSpy = injectSpy(moduleRef, UserService);
+});
+
+it('logs in a known user', () => {
+  userServiceSpy.findByEmail.mockReturnValue({ id: 1, name: 'Ada' });
+
+  const auth = moduleRef.get(AuthService);
+  expect(auth.login('ada@example.com')).toBeTruthy();
+  expect(userServiceSpy.findByEmail).toHaveBeenCalledWith('ada@example.com');
+});
+```
+
+### React (Testing Library)
+
+React has no DI container, so there's no `provide*` helper — the recipe is: **spy the classes you
+own** (services, stores, API clients, hook deps), then pass the spy into a Context provider or hook.
+The spy is a plain object of spied functions, so it drops straight into `value={...}`:
+
+```tsx
+import { render, screen } from '@testing-library/react';
+import { createSpyFromClass, type Spy } from 'vitest-auto-spy/react';
+import { CartContext, Cart } from './cart';
+
+class CartStore {
+  getItemCount(): number { return 0; }
+  checkout(token: string): Promise<{ orderId: string }> { /* ... */ }
+}
+
+let cart: Spy<CartStore>;
+
+beforeEach(() => {
+  cart = createSpyFromClass(CartStore); // every method is now a spy
+});
+
+it('shows the item count from the injected store', () => {
+  cart.getItemCount.mockReturnValue(3);
+
+  render(
+    <CartContext.Provider value={cart}>
+      <Cart />
+    </CartContext.Provider>,
+  );
+
+  expect(screen.getByText('3 items')).toBeInTheDocument();
+});
+
+it('drives async deps and asserts the component called them', async () => {
+  cart.checkout.resolveWith({ orderId: 'ord_42' });
+  // ...trigger checkout in the UI...
+  expect(cart.checkout).toHaveBeenCalledWith('tok_abc');
+});
+```
+
+### Vue / Pinia
+
+`provideAutoSpy(token, Class)` returns a `{ [token]: Spy<T> }` map you can spread into
+`@vue/test-utils`' `global.provide`; for a class-based Pinia store, spy it directly:
+
+```ts
+import { mount } from '@vue/test-utils';
+import { createSpyFromClass, provideAutoSpy } from 'vitest-auto-spy/vue';
+
+// (a) class-based service injected via provide / global.provide
+import { UserServiceKey, UserService } from '@/services/user.service';
+
+const provide = provideAutoSpy(UserServiceKey, UserService); // { [UserServiceKey]: Spy<UserService> }
+provide[UserServiceKey].getName.mockReturnValue('Fake Name');
+
+const wrapper = mount(UserBadge, { global: { provide } });
+expect(provide[UserServiceKey].getName).toHaveBeenCalled();
+
+// (b) class-based Pinia store — every action becomes a spy
+import { CartStore } from '@/stores/cart.store';
+
+const store = createSpyFromClass(CartStore);
+store.itemCount.mockReturnValue(3);                  // sync action/getter
+store.checkout.resolveWith({ orderId: 'ord_42' });   // async action (Promise)
+await store.checkout('tok_abc');
+expect(store.checkout).toHaveBeenCalledWith('tok_abc');
+```
+
+### Svelte
+
+Svelte has no class-based DI, so it's a recipe: keep your logic in plain class-based
+services/stores, spy the class, and hand the spy to the component the same way it receives the real
+one (props, context, or a mocked module):
+
+```ts
+import { render } from '@testing-library/svelte';
+import { createSpyFromClass } from 'vitest-auto-spy/svelte';
+import Cart from './Cart.svelte';
+import { CartStore } from './cart-store';
+
+it('shows the cart total from the store', () => {
+  const cartStore = createSpyFromClass(CartStore); // every method is a spy
+
+  cartStore.total.mockReturnValue(42);
+  cartStore.priceOf.calledWith('apple').mockReturnValue(7);
+
+  render(Cart, { props: { store: cartStore } });
+
+  expect(cartStore.total).toHaveBeenCalled();
+});
+```
+
+### Angular
 
 `provideAutoSpy` is the shorthand for providing an auto-spy in a `TestBed`:
 
@@ -274,7 +616,7 @@ beforeEach(() => {
 > [`@analogjs/vite-plugin-angular`](https://www.npmjs.com/package/@analogjs/vite-plugin-angular)
 > plus a TestBed setup file (e.g. `@analogjs/vitest-angular`'s `setupTestBed()`).
 
-### Signal / readonly property mocking (bonus)
+#### Signal / readonly property mocking (bonus)
 
 ```ts
 import { mockReadonlyProp, mockReadonlyPropGetter, mockAccessorsProp } from 'vitest-auto-spy/angular';
@@ -289,8 +631,10 @@ mockAccessorsProp(service, 'theme');                     // spied get + set
 | Export | Description |
 | --- | --- |
 | `createSpyFromClass(Class, methodsOrConfig?)` | Build a fully-typed `Spy<T>` from a class |
-| `provideAutoSpy(Class, methodsOrConfig?)` | Angular `{ provide, useValue }` shorthand |
-| `injectSpy(token)` | `TestBed.inject` typed as `Spy<T>` |
+| `createAutoMock<T>(overrides?)` | Build a `Spy<T>` from a **type/interface** alone (Proxy, no class) |
+| `provideAutoSpy(Class, methodsOrConfig?)` | Angular / NestJS `{ provide, useValue }` shorthand |
+| `provideAutoSpy(token, Class, methodsOrConfig?)` | Vue `{ [token]: Spy<T> }` for `global.provide` |
+| `injectSpy(token)` _(Angular)_ / `injectSpy(moduleRef, token)` _(NestJS)_ | Inject typed as `Spy<T>` |
 | `createFunctionSpy(name)` | A single standalone function spy with all helpers |
 | `createObservableWithValues(configs, opts?)` | Build an Observable from value configs |
 | `mockReadonlyProp` / `mockReadonlyPropGetter` / `mockAccessorsProp` | Mock readonly / accessor / signal props |
@@ -308,6 +652,38 @@ mockAccessorsProp(service, 'theme');                     // spied get + set
 
 `ValueConfig` (for `nextWithValues`): `{ value, delay? }` | `{ errorValue, delay? }` | `{ complete?, delay? }`.
 
+## FAQ & troubleshooting
+
+**"I get `X.nextWith is not a function` / observable helpers are missing."**
+Import the rxjs layer once (e.g. in your test setup): `import 'vitest-auto-spy/rxjs';`. Without it,
+requesting an observable spy throws a hint pointing you here.
+
+**"My method isn't on the spy."**
+Auto-discovery only sees **prototype methods**. Arrow-function class fields (`foo = () => {}`) and
+plain properties aren't included — see [How it works](#how-it-works-and-what-it-wont-spy). List
+getters/setters via `gettersToSpyOn` / `settersToSpyOn`.
+
+**"Does it construct my class? Will the constructor's side effects run?"**
+No. `createSpyFromClass` reads the prototype and never `new`s the class, so constructors (and their
+HTTP/DB/`inject()` side effects) never run.
+
+**"I only have an interface/type, not a class."**
+Use [`createAutoMock<T>()`](#auto-mock-by-type-no-class-needed) — it builds the spy lazily from the
+type via a `Proxy`, no runtime class needed.
+
+**"Can I use it without TypeScript?"**
+Yes — the runtime works in plain JS; you just lose the compile-time `Spy<T>` typing.
+
+**"Native mock methods differ between runners."**
+Only the auto-spy helpers are normalised. Native APIs stay the runner's own (`mockReturnValue` on
+Vitest/Bun, `spy.method.mock.mockImplementation` on `node:test`).
+
+## Versioning
+
+This package follows [Semantic Versioning](https://semver.org). Breaking changes to the public API
+land only in major releases; see the [Changelog](./CHANGELOG.md) for what changed in each version.
+Releases are automated from Conventional Commits (see [Contributing](#contributing)).
+
 ## Contributing
 
 Contributions are welcome! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) and the
@@ -322,11 +698,18 @@ npm run build
 
 Releases are automated: merging a PR into `master` bumps the version from the
 Conventional Commit types and publishes to npm — see
-[CONTRIBUTING.md → Releases](./CONTRIBUTING.md#releases).
+[CONTRIBUTING.md → Releasing](./CONTRIBUTING.md#releasing).
 
 If this package saved you time, a ⭐ on [GitHub](https://github.com/ASDAlexey/vitest-auto-spy)
 helps others find it.
 
+## Acknowledgements
+
+API and ergonomics are modelled on Shai Reznik's
+[`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spies) — `vitest-auto-spy` is its
+Vitest-era successor with the same surface, so migrations are (mostly) a find-and-replace. Thanks to
+the Vitest, Bun, RxJS and Angular communities whose tooling this builds on.
+
 ## License
 
 [MIT](./LICENSE) © [Alexey Popov](https://github.com/ASDAlexey)

package/dist/angular.cjs

@@ -1 +1 @@
-'use strict';var testing=require('@angular/core/testing'),vitest=require('vitest');function g(e,t){Object.defineProperty(e,t,{get(){},set(r){},configurable:true});}function T(e,t,r){let n=t;return r==="setter"?vitest.vi.spyOn(e,n,"set"):vitest.vi.spyOn(e,n,"get")}function b(e,t,r){let n={getters:{},setters:{}};e.accessorSpies=n,t.forEach(o=>{g(e,o),n.getters[o]=T(e,o,"getter");}),r.forEach(o=>{Object.prototype.hasOwnProperty.call(e,o)||g(e,o),n.setters[o]=T(e,o,"setter");});}function A(e){return `'${e.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}'`}function M(e,t){return Object.entries(e).map(([r,n])=>`${r}:${i(n,t)}`).join(",")}function W(e,t){return `new Map([${[...e.entries()].map(([n,o])=>`[${i(n,t)},${i(o,t)}]`).join(",")}])`}function F(e,t){if(t.has(e))return "[Circular]";t.add(e);let r;return e instanceof Date?r=`new Date(${e.getTime()})`:e instanceof Map?r=W(e,t):e instanceof Set?r=`new Set([${[...e].map(n=>i(n,t)).join(",")}])`:Array.isArray(e)?r=`[${e.map(n=>i(n,t)).join(",")}]`:r=`{${M(e,t)}}`,t.delete(e),r}function i(e,t=new WeakSet){return typeof e=="string"?A(e):typeof e=="bigint"?`${e}n`:typeof e=="symbol"?e.toString():typeof e=="function"?`[Function: ${e.name}]`:typeof e=="object"&&e!==null?F(e,t):Object.is(e,-0)?"-0":String(e)}var l=class{#e={};set(t,r){this.#e[this.#t(t)]=r;}get(t){return this.#e[this.#t(t)]}#t(t){return i(t)}};var E=e=>`The function '${e}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `,_="But the function was called without any arguments.",$=e=>{let t=i(e);return `But the actual arguments were: ${t.substring(1,t.length-1)}`},m={throwArgumentsError(e,t){let r=e.length===0?_:$(e);throw new Error(E(t)+r)}};var H="Observable spies require rxjs. Import 'vitest-auto-spy/rxjs' once (e.g. in your test setup) to enable observablePropsToSpyOn / nextWith / nextWithValues / throwWith / complete / returnSubject.";function S(){throw new Error(H);}function a(e,t){return Object.assign(e,t)}function K(e){return e.map(t=>({wrappedValue:t.delay===void 0?Promise.resolve(t.value):new Promise(r=>setTimeout(()=>r(t.value),t.delay))}))}function O(e,t){a(e,{resolveWith:r=>{t({value:Promise.resolve(r)});},rejectWith:r=>{t({value:r,_isRejectedPromise:true});},resolveWithPerCall:r=>{r.length!==0&&t({value:void 0,valuesPerCalls:K(r)});}});}function C(e,t){O(e,r=>{t.value=r.value,t._isRejectedPromise=r._isRejectedPromise??false,t.valuesPerCalls=r.valuesPerCalls??[];});}function j(e,t){O(e,r=>{e.argsToValuesMap.set(t,r);});}function B(e){return typeof e=="object"&&e!==null&&"value"in e}function v(e){if(e._isRejectedPromise)return Promise.reject(e.value);let t=e.valuesPerCalls?.shift();return t?t.wrappedValue:e.value}function h(e,t){let r=e.argsToValuesMap.get(t);return B(r)?{found:true,value:v(r)}:{found:false,value:void 0}}function I(e,t,r,n,o){if(e.wasConfigured){let s=h(e,n);if(s.found)return s.value}if(t.wasConfigured){let s=h(t,n);if(s.found)return s.value;m.throwArgumentsError(n,o);}return v(r)}function w(e,t){return e.wasConfigured=true,a(e,{mockReturnValue:r=>{e.argsToValuesMap.set(t,{value:r});}}),j(e,t),e}function k(){return {wasConfigured:false,argsToValuesMap:new l}}function P(e){let t=k(),r=k(),n={value:void 0},o=vitest.vi.fn((...u)=>I(t,r,n,u,e));o.mockName(e),C(o,n);let s=a(o,{calledWith:(...u)=>w(t,u),mustBeCalledWith:(...u)=>w(r,u)});return s}var R={methodsToSpyOn:[],observablePropsToSpyOn:[],settersToSpyOn:[],gettersToSpyOn:[]};function G(e){let t=Object.getOwnPropertyDescriptors(e);return Object.keys(t).filter(r=>r!=="constructor"&&!t[r]?.get)}function q(e){let t=new Set,r=e;for(;r;){let n=Object.getPrototypeOf(r);n&&G(r).forEach(o=>t.add(o)),r=n;}return [...t]}function D(e){return e?Array.isArray(e)?{...R,methodsToSpyOn:e}:{methodsToSpyOn:e.methodsToSpyOn??[],observablePropsToSpyOn:e.observablePropsToSpyOn??[],settersToSpyOn:e.settersToSpyOn??[],gettersToSpyOn:e.gettersToSpyOn??[]}:{...R}}function x(e,t){let{methodsToSpyOn:r,observablePropsToSpyOn:n,settersToSpyOn:o,gettersToSpyOn:s}=D(t),u=r.length>0?r:q(e.prototype),p={};return n.forEach(c=>{p[c]=S().createPropSpy();}),b(p,s,o),u.forEach(c=>{p[c]=P(c);}),p}function L(e,t){return {provide:e,useValue:x(e,t)}}function N(e){return testing.TestBed.inject(e)}function J(e,t,r){Object.defineProperty(e,t,{get:()=>r,configurable:true});}function X(e,t,r){Object.defineProperty(e,t,{get:r,configurable:true});}function Y(e,t){Object.defineProperty(e,t,{get:vitest.vi.fn(),set:vitest.vi.fn(),configurable:true});}exports.injectSpy=N;exports.mockAccessorsProp=Y;exports.mockReadonlyProp=J;exports.mockReadonlyPropGetter=X;exports.provideAutoSpy=L;
+'use strict';var vitest=require('vitest'),testing=require('@angular/core/testing');var y;function b(e){y=e;}var W="No mock adapter registered. Import a runtime entry once before creating spies \u2014 'vitest-auto-spy' (default, Vitest) or a runtime variant such as 'vitest-auto-spy/bun'.";function p(){if(!y)throw new Error(W);return y}var k={createMockFn(e,t){let r=e?vitest.vi.fn(e):vitest.vi.fn();return t!==void 0&&r.mockName(t),r},spyOnGetter(e,t){return vitest.vi.spyOn(e,t,"get")},spyOnSetter(e,t){return vitest.vi.spyOn(e,t,"set")},getCalls(e){return e.mock.calls},reset(e){e.mockReset();}};function T(e,t){Object.defineProperty(e,t,{get(){},set(r){},configurable:true});}function S(e,t,r){let n=p();return r==="setter"?n.spyOnSetter(e,t):n.spyOnGetter(e,t)}function O(e,t,r){let n={getters:{},setters:{}};e.accessorSpies=n,t.forEach(o=>{T(e,o),n.getters[o]=S(e,o,"getter");}),r.forEach(o=>{Object.prototype.hasOwnProperty.call(e,o)||T(e,o),n.setters[o]=S(e,o,"setter");});}function E(e){return `'${e.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}'`}function _(e,t){return Object.entries(e).map(([r,n])=>`${r}:${i(n,t)}`).join(",")}function $(e,t){return `new Map([${[...e.entries()].map(([n,o])=>`[${i(n,t)},${i(o,t)}]`).join(",")}])`}function H(e,t){if(t.has(e))return "[Circular]";t.add(e);let r;return e instanceof Date?r=`new Date(${e.getTime()})`:e instanceof Map?r=$(e,t):e instanceof Set?r=`new Set([${[...e].map(n=>i(n,t)).join(",")}])`:Array.isArray(e)?r=`[${e.map(n=>i(n,t)).join(",")}]`:r=`{${_(e,t)}}`,t.delete(e),r}function i(e,t=new WeakSet){return typeof e=="string"?E(e):typeof e=="bigint"?`${e}n`:typeof e=="symbol"?e.toString():typeof e=="function"?`[Function: ${e.name}]`:typeof e=="object"&&e!==null?H(e,t):Object.is(e,-0)?"-0":String(e)}var f=class{#e={};set(t,r){this.#e[this.#t(t)]=r;}get(t){return this.#e[this.#t(t)]}#t(t){return i(t)}};var K=e=>`The function '${e}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `,z="But the function was called without any arguments.",B=e=>{let t=i(e);return `But the actual arguments were: ${t.substring(1,t.length-1)}`},j={throwArgumentsError(e,t){let r=e.length===0?z:B(e);throw new Error(K(t)+r)}};var G="Observable spies require rxjs. Import 'vitest-auto-spy/rxjs' once (e.g. in your test setup) to enable observablePropsToSpyOn / nextWith / nextWithValues / throwWith / complete / returnSubject.";function C(){throw new Error(G);}function a(e,t){return Object.assign(e,t)}function I(e){return e.map(t=>({wrappedValue:t.delay===void 0?Promise.resolve(t.value):new Promise(r=>setTimeout(()=>r(t.value),t.delay))}))}function w(e,t){a(e,{resolveWith:r=>{t({value:Promise.resolve(r)});},rejectWith:r=>{t({value:r,_isRejectedPromise:true});},resolveWithPerCall:r=>{r.length!==0&&t({value:void 0,valuesPerCalls:I(r)});}});}function h(e,t){w(e,r=>{t.value=r.value,t._isRejectedPromise=r._isRejectedPromise??false,t.valuesPerCalls=r.valuesPerCalls??[];});}function M(e,t){w(e,r=>{e.argsToValuesMap.set(t,r);});}function D(e){return typeof e=="object"&&e!==null&&"value"in e}function F(e){if(e._isRejectedPromise)return Promise.reject(e.value);let t=e.valuesPerCalls?.shift();return t?t.wrappedValue:e.value}function v(e,t){let r=e.argsToValuesMap.get(t);return D(r)?{found:true,value:F(r)}:{found:false,value:void 0}}function q(e,t,r,n,o){if(e.wasConfigured){let s=v(e,n);if(s.found)return s.value}if(t.wasConfigured){let s=v(t,n);if(s.found)return s.value;j.throwArgumentsError(n,o);}return F(r)}function P(e,t){return e.wasConfigured=true,a(e,{mockReturnValue:r=>{e.argsToValuesMap.set(t,{value:r});}}),M(e,t),e}function A(){return {wasConfigured:false,argsToValuesMap:new f}}function R(e){let t=A(),r=A(),n={value:void 0},o=p().createMockFn((...c)=>q(t,r,n,c,e),e);h(o,n);let s=a(o,{calledWith:(...c)=>P(t,c),mustBeCalledWith:(...c)=>P(r,c)});return s}var x={methodsToSpyOn:[],observablePropsToSpyOn:[],settersToSpyOn:[],gettersToSpyOn:[]};function U(e){let t=Object.getOwnPropertyDescriptors(e);return Object.keys(t).filter(r=>r!=="constructor"&&!t[r]?.get)}function L(e){let t=new Set,r=e;for(;r;){let n=Object.getPrototypeOf(r);n&&U(r).forEach(o=>t.add(o)),r=n;}return [...t]}function N(e){return e?Array.isArray(e)?{...x,methodsToSpyOn:e}:{methodsToSpyOn:e.methodsToSpyOn??[],observablePropsToSpyOn:e.observablePropsToSpyOn??[],settersToSpyOn:e.settersToSpyOn??[],gettersToSpyOn:e.gettersToSpyOn??[]}:{...x}}function V(e,t){let{methodsToSpyOn:r,observablePropsToSpyOn:n,settersToSpyOn:o,gettersToSpyOn:s}=N(t),c=r.length>0?r:L(e.prototype),u={};return n.forEach(l=>{u[l]=C().createPropSpy();}),O(u,s,o),c.forEach(l=>{u[l]=R(l);}),u}function X(e,t){return {provide:e,useValue:V(e,t)}}function Y(e){return testing.TestBed.inject(e)}function Q(e,t,r){Object.defineProperty(e,t,{get:()=>r,configurable:true});}function Z(e,t,r){Object.defineProperty(e,t,{get:r,configurable:true});}function ee(e,t){let r=p();Object.defineProperty(e,t,{get:r.createMockFn(),set:r.createMockFn(),configurable:true});}b(k);exports.injectSpy=Y;exports.mockAccessorsProp=ee;exports.mockReadonlyProp=Q;exports.mockReadonlyPropGetter=Z;exports.provideAutoSpy=X;

package/dist/angular.d.cts

@@ -1,4 +1,4 @@
-import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-Cg9eZmvm.cjs';
+import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-C84-zP_V.cjs';
 import 'rxjs';
 import 'vitest';
 
@@ -15,7 +15,7 @@ declare function injectSpy<T>(token: ClassType<T> | (abstract new (...args: neve
 declare function mockReadonlyProp<T, K extends keyof T>(object: T, property: K, value: T[K]): void;
 /** Override a readonly property with a dynamic getter. */
 declare function mockReadonlyPropGetter<T, K extends keyof T>(object: T, property: K, getter: () => unknown): void;
-/** Replace a property with spied `get`/`set` accessors (`vi.fn()`). */
+/** Replace a property with spied `get`/`set` accessors (host-runner mocks). */
 declare function mockAccessorsProp<T, K extends keyof T>(object: T, property: K): void;
 
 export { type AngularValueProvider, injectSpy, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, provideAutoSpy };

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-Cg9eZmvm.js';
+import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-C84-zP_V.js';
 import 'rxjs';
 import 'vitest';
 
@@ -15,7 +15,7 @@ declare function injectSpy<T>(token: ClassType<T> | (abstract new (...args: neve
 declare function mockReadonlyProp<T, K extends keyof T>(object: T, property: K, value: T[K]): void;
 /** Override a readonly property with a dynamic getter. */
 declare function mockReadonlyPropGetter<T, K extends keyof T>(object: T, property: K, getter: () => unknown): void;
-/** Replace a property with spied `get`/`set` accessors (`vi.fn()`). */
+/** Replace a property with spied `get`/`set` accessors (host-runner mocks). */
 declare function mockAccessorsProp<T, K extends keyof T>(object: T, property: K): void;
 
 export { type AngularValueProvider, injectSpy, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, provideAutoSpy };

package/dist/angular.js

@@ -1 +1 @@
-import {c as c$1}from'./chunk-6S2BI3IA.js';import'./chunk-7IUYJ6ZW.js';import {TestBed}from'@angular/core/testing';import {vi}from'vitest';function i(e,o){return {provide:e,useValue:c$1(e,o)}}function s(e){return TestBed.inject(e)}function y(e,o,r){Object.defineProperty(e,o,{get:()=>r,configurable:true});}function a(e,o,r){Object.defineProperty(e,o,{get:r,configurable:true});}function c(e,o){Object.defineProperty(e,o,{get:vi.fn(),set:vi.fn(),configurable:true});}export{s as injectSpy,c as mockAccessorsProp,y as mockReadonlyProp,a as mockReadonlyPropGetter,i as provideAutoSpy};
+import {a as a$1}from'./chunk-6LFQMHSX.js';import {a,e,b}from'./chunk-VLNCYBUN.js';import'./chunk-7IUYJ6ZW.js';import {TestBed}from'@angular/core/testing';function c(e$1,o){return {provide:e$1,useValue:e(e$1,o)}}function s(e){return TestBed.inject(e)}function y(e,o,r){Object.defineProperty(e,o,{get:()=>r,configurable:true});}function d(e,o,r){Object.defineProperty(e,o,{get:r,configurable:true});}function u(e,o){let r=b();Object.defineProperty(e,o,{get:r.createMockFn(),set:r.createMockFn(),configurable:true});}a(a$1);export{s as injectSpy,u as mockAccessorsProp,y as mockReadonlyProp,d as mockReadonlyPropGetter,c as provideAutoSpy};

package/dist/bun.cjs

@@ -0,0 +1 @@
+'use strict';var bun_test=require('bun:test');function S({createMockFn:e,getCalls:t,reset:r}){return {createMockFn:e,spyOnGetter:(o,n)=>b(e,o,n,"get"),spyOnSetter:(o,n)=>b(e,o,n,"set"),getCalls:t,reset:r}}function b(e,t,r,o){let n=Object.getOwnPropertyDescriptor(t,r),s=o==="get"?n?.get:n?.set,i=e(s),c={configurable:true,enumerable:n?.enumerable??true};return n?.get&&(c.get=n.get),n?.set&&(c.set=n.set),o==="get"?c.get=i:c.set=i,Object.defineProperty(t,r,c),i}function w(e){return S({createMockFn:(r,o)=>{let n=e.mock(r??(()=>{}));return o!==void 0&&n.mockName&&n.mockName(o),n},getCalls:r=>r.mock.calls,reset:r=>r.mockReset()})}var y;function M(e){y=e;}var W="No mock adapter registered. Import a runtime entry once before creating spies \u2014 'vitest-auto-spy' (default, Vitest) or a runtime variant such as 'vitest-auto-spy/bun'.";function d(){if(!y)throw new Error(W);return y}function O(e,t){Object.defineProperty(e,t,{get(){},set(r){},configurable:true});}function T(e,t,r){let o=d();return r==="setter"?o.spyOnSetter(e,t):o.spyOnGetter(e,t)}function h(e,t,r){let o={getters:{},setters:{}};e.accessorSpies=o,t.forEach(n=>{O(e,n),o.getters[n]=T(e,n,"getter");}),r.forEach(n=>{Object.prototype.hasOwnProperty.call(e,n)||O(e,n),o.setters[n]=T(e,n,"setter");});}function E(e){return `'${e.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}'`}function _(e,t){return Object.entries(e).map(([r,o])=>`${r}:${a(o,t)}`).join(",")}function B(e,t){return `new Map([${[...e.entries()].map(([o,n])=>`[${a(o,t)},${a(n,t)}]`).join(",")}])`}function H(e,t){if(t.has(e))return "[Circular]";t.add(e);let r;return e instanceof Date?r=`new Date(${e.getTime()})`:e instanceof Map?r=B(e,t):e instanceof Set?r=`new Set([${[...e].map(o=>a(o,t)).join(",")}])`:Array.isArray(e)?r=`[${e.map(o=>a(o,t)).join(",")}]`:r=`{${_(e,t)}}`,t.delete(e),r}function a(e,t=new WeakSet){return typeof e=="string"?E(e):typeof e=="bigint"?`${e}n`:typeof e=="symbol"?e.toString():typeof e=="function"?`[Function: ${e.name}]`:typeof e=="object"&&e!==null?H(e,t):Object.is(e,-0)?"-0":String(e)}var f=class{#e={};set(t,r){this.#e[this.#t(t)]=r;}get(t){return this.#e[this.#t(t)]}#t(t){return a(t)}};var $=e=>`The function '${e}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `,z="But the function was called without any arguments.",D=e=>{let t=a(e);return `But the actual arguments were: ${t.substring(1,t.length-1)}`},m={throwArgumentsError(e,t){let r=e.length===0?z:D(e);throw new Error($(t)+r)}};var I="Observable spies require rxjs. Import 'vitest-auto-spy/rxjs' once (e.g. in your test setup) to enable observablePropsToSpyOn / nextWith / nextWithValues / throwWith / complete / returnSubject.";function C(){throw new Error(I);}function u(e,t){return Object.assign(e,t)}function G(e){return e.map(t=>({wrappedValue:t.delay===void 0?Promise.resolve(t.value):new Promise(r=>setTimeout(()=>r(t.value),t.delay))}))}function j(e,t){u(e,{resolveWith:r=>{t({value:Promise.resolve(r)});},rejectWith:r=>{t({value:r,_isRejectedPromise:true});},resolveWithPerCall:r=>{r.length!==0&&t({value:void 0,valuesPerCalls:G(r)});}});}function F(e,t){j(e,r=>{t.value=r.value,t._isRejectedPromise=r._isRejectedPromise??false,t.valuesPerCalls=r.valuesPerCalls??[];});}function A(e,t){j(e,r=>{e.argsToValuesMap.set(t,r);});}function K(e){return typeof e=="object"&&e!==null&&"value"in e}function x(e){if(e._isRejectedPromise)return Promise.reject(e.value);let t=e.valuesPerCalls?.shift();return t?t.wrappedValue:e.value}function P(e,t){let r=e.argsToValuesMap.get(t);return K(r)?{found:true,value:x(r)}:{found:false,value:void 0}}function N(e,t,r,o,n){if(e.wasConfigured){let s=P(e,o);if(s.found)return s.value}if(t.wasConfigured){let s=P(t,o);if(s.found)return s.value;m.throwArgumentsError(o,n);}return x(r)}function v(e,t){return e.wasConfigured=true,u(e,{mockReturnValue:r=>{e.argsToValuesMap.set(t,{value:r});}}),A(e,t),e}function R(){return {wasConfigured:false,argsToValuesMap:new f}}function p(e){let t=R(),r=R(),o={value:void 0},n=d().createMockFn((...i)=>N(t,r,o,i,e),e);F(n,o);let s=u(n,{calledWith:(...i)=>v(t,i),mustBeCalledWith:(...i)=>v(r,i)});return s}var V={methodsToSpyOn:[],observablePropsToSpyOn:[],settersToSpyOn:[],gettersToSpyOn:[]};function q(e){let t=Object.getOwnPropertyDescriptors(e);return Object.keys(t).filter(r=>r!=="constructor"&&!t[r]?.get)}function U(e){let t=new Set,r=e;for(;r;){let o=Object.getPrototypeOf(r);o&&q(r).forEach(n=>t.add(n)),r=o;}return [...t]}function L(e){return e?Array.isArray(e)?{...V,methodsToSpyOn:e}:{methodsToSpyOn:e.methodsToSpyOn??[],observablePropsToSpyOn:e.observablePropsToSpyOn??[],settersToSpyOn:e.settersToSpyOn??[],gettersToSpyOn:e.gettersToSpyOn??[]}:{...V}}function J(e,t){let{methodsToSpyOn:r,observablePropsToSpyOn:o,settersToSpyOn:n,gettersToSpyOn:s}=L(t),i=r.length>0?r:U(e.prototype),c={};return o.forEach(l=>{c[l]=C().createPropSpy();}),h(c,s,n),i.forEach(l=>{c[l]=p(l);}),c}function X(e={}){let t=new Map;for(let o of Reflect.ownKeys(e))t.set(o,Reflect.get(e,o));let r={get(o,n){if(t.has(n))return t.get(n);if(typeof n=="symbol"||n==="then"||n==="constructor")return;let s=p(String(n));return t.set(n,s),s},set(o,n,s){return t.set(n,s),true},has(o,n){return t.has(n)},ownKeys(){return [...t.keys()]},getOwnPropertyDescriptor(o,n){if(t.has(n))return {configurable:true,enumerable:true,value:t.get(n),writable:true}}};return new Proxy({},r)}M(w({mock:bun_test.mock}));exports.createAutoMock=X;exports.createFunctionSpy=p;exports.createSpyFromClass=J;exports.errorHandler=m;