vitest-auto-spy 5.60.0 → 5.63.0

package/AGENTS.md

@@ -250,6 +250,9 @@ Rules that carry most of the value:
 In [`agent-docs/return-helpers.md`](./agent-docs/return-helpers.md). Read it when stubbing a return value: `calledWith`, `resolveWith`, `nextWith`, `returnSubject` and the rest, by return type.
 
 <!-- agents-outline: agent-docs/return-helpers.md -->
+
+- Keeping an awaited collaborator pending
+
 <!-- /agents-outline -->
 
 ---
@@ -455,6 +458,7 @@ In [`agent-docs/doubles.md`](./agent-docs/doubles.md). Read it when production c
 ## 13. Angular
 
 In [`agent-docs/angular.md`](./agent-docs/angular.md). Read it for any spec that uses `TestBed`, signals, Angular HTTP, the router or an Angular double.
+For selected void window methods, use `createWindowSpies` from `/angular/doubles`; the window recipe is in that file.
 
 <!-- agents-outline: agent-docs/angular.md -->
 

package/CHANGELOG.md

@@ -10,6 +10,29 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.63.0] - 2026-10-21
+
+### Added
+
+- `createDeferred<T>()` returns a typed pending promise with detached `resolve` and `reject`
+  functions, for assertions before an awaited collaborator finishes. It defaults to `void` and
+  works on supported runtimes without `Promise.withResolvers`.
+
+## [5.62.0] - 2026-10-20
+
+### Fixed
+
+- **`prefer-settle-dynamic-import` recognises Angular provider setup in setup hooks.** A namespace
+  loaded for providers is allowed after logger or fixture preparation. Imports after application
+  actions remain checked. The English and Russian rule guides distinguish provider loading from
+  waiting for handlers, and clarify that `Promise.resolve()` does not take an event-loop turn.
+
+## [5.61.0] - 2026-10-07
+
+### Added
+
+- `createWindowSpies` in `/angular/doubles`: typed, configured no-op spies for selected void window methods, including `location.reload` and `parent.postMessage`, composable with existing window overrides.
+
 ## [5.60.0] - 2026-10-06
 
 ### Added
@@ -6841,7 +6864,10 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.60.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.63.0...HEAD
+[5.63.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.62.0...v5.63.0
+[5.62.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.61.0...v5.62.0
+[5.61.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.60.0...v5.61.0
 [5.60.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.1...v5.60.0
 [5.59.1]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.0...v5.59.1
 [5.59.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.58.0...v5.59.0

package/README.md

@@ -15,7 +15,7 @@ replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spie
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-30.3%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-30.4%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![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)
@@ -42,6 +42,7 @@ replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spie
 
 - **A spy of every method from a class**, typed, with helpers that match each return type:
   `resolveWith` for a `Promise`, `nextWith` for an `Observable`, `mockReturnValue` for the rest.
+  `createDeferred<T>()` keeps an awaited collaborator pending until the test releases it.
 - **Answers per argument list**: `calledWith(1).mockReturnValue(...)`.
 - **A spy from a type alone**: `createAutoMock<T>()` and `mockDeep<T>()`.
 - **Angular `TestBed` in one line**: `provideAutoSpy(ApiService)`, then `injectSpy(ApiService)`.
@@ -1167,6 +1168,7 @@ that keeps the cut inside; `node scripts/check-readme-npm-cut.mjs --write` resiz
 - [Synchronous methods](#synchronous-methods)
   - [Matching order, and re-configuring the same arguments](#matching-order-and-re-configuring-the-same-arguments)
 - [Promise-returning methods](#promise-returning-methods)
+  - [Keeping a promise pending](#keeping-a-promise-pending--createdeferred)
 - [Observable-returning methods & Observable properties](#observable-returning-methods--observable-properties)
   - [Standalone observable builder](#standalone-observable-builder)
 - [Getters & setters](#getters--setters)
@@ -2360,6 +2362,33 @@ myService.getProducts.resolveWithPerCall([{ value: ['a'] }, { value: ['b'] }]);
 myService.getProducts.calledWith(1).resolveWith(['one']);
 ```
 
+### Keeping a promise pending — `createDeferred`
+
+`createDeferred<T>()` returns `{ promise, resolve, reject }`. Use it to check what happens before
+an awaited collaborator finishes, then release that collaborator without timers.
+
+```ts
+import { expect } from 'vitest';
+import { createDeferred } from 'vitest-auto-spy';
+
+const home = createDeferred<boolean>();
+const events: string[] = [];
+const navigation = home.promise.then((ok) => {
+  events.push('deeplink');
+  return ok;
+});
+expect(events).toEqual([]);
+home.resolve(true);
+await expect(navigation).resolves.toBe(true);
+expect(events).toEqual(['deeplink']);
+```
+
+`resolve` accepts a value or a `PromiseLike<T>`; `reject(reason)` rejects with that reason.
+`createDeferred()` defaults to `void`, so `resolve()` needs no argument. Settle the promise before
+awaiting the operation that depends on it, or the test will wait forever. Each call creates an
+independent native promise; the first settlement wins. No fake timers or `Promise.withResolvers`
+are required. Import from `/bun`, `/node` or `/rstest` when using those runners.
+
 ## Observable-returning methods & Observable properties
 
 Methods that return an `Observable`, and `Observable` properties listed in `observablePropsToSpyOn`,
@@ -3125,6 +3154,7 @@ only the ones you need. Every helper, with its signature: [API](https://asdalexe
 | `provideLocationDouble()` / `injectLocationDouble()` / `createLocationDouble()`                             | `/angular-router`             | Angular's own `SpyLocation` and `MockLocationStrategy` in one call — a real history, the `urlChanges` journal, `simulateUrlPop()` / `simulateHashChange()` for the browser's half of the contract; `Location` is `providedIn: 'root'`, so a spec that forgets the provider silently drives the platform's real one                                                                        |
 | `createForm(model, schema?)` / `registerFormMatchers()`                                                     | `/signal-forms`               | A signal form built where `form()` can inject, and `expect(field).toHaveFieldErrors(['required'])` over what it produced                                                                                                                                                                                                                                                                  |
 | `provideWindowDouble(TOKEN, over?)` / `provideDocumentDouble(over?)`                                        | `/angular/doubles`            | A `window` / `document` merged **over** the real jsdom one, so members the spec never named still answer; the globals stay untouched                                                                                                                                                                                                                                                      |
+| `createWindowSpies(selection)`                                                                              | `/angular/doubles`            | Typed no-op spies for selected void window methods: `createWindowSpies({ location: ['reload'], parent: ['postMessage'] })`; pass them as window overrides.                                                                                                                                                                                                                                |
 | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(Ref, init?)`                                     | `/angular/doubles`            | The Material dialog trio without `@angular/material` as a dependency — the token and the ref class are arguments, `afterClosed()` still answers after the close                                                                                                                                                                                                                           |
 | `providePlatform(platform, flags?)`                                                                         | `/angular/doubles`            | `PLATFORM_ID` plus the app's own `isBrowser` / `isServer` tokens, always agreeing                                                                                                                                                                                                                                                                                                         |
 | `provideDomSanitizerDouble()` / `provideChangeDetectorRefDouble()`                                          | `/angular/doubles`            | A `DomSanitizer` whose bypass spies return Angular's real safe values; a `ChangeDetectorRef` of four spies answering `undefined` (`create…Double()` for the bare double)                                                                                                                                                                                                                  |

package/agent-docs/angular.md

@@ -862,6 +862,32 @@ Five things to know:
   `win.Promise.resolve()`, `win.Object.keys(x)` and `new win.Event('x')` work, and
   `win.Event === window.Event` holds — which is what `instanceof` in production code needs.
 
+`createWindowSpies` creates typed spies for selected `void` methods, including nested window members.
+The spies return `undefined` without invoking browser methods.
+
+```ts
+import { InjectionToken } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { expect } from 'vitest';
+import { createWindowSpies, provideWindowDouble } from 'vitest-auto-spy/angular/doubles';
+
+const WINDOW = new InjectionToken<Window>('WINDOW');
+const spies = createWindowSpies({ location: ['reload'], parent: ['postMessage'] });
+TestBed.configureTestingModule({
+  providers: [provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'tv.kion.ru' } })],
+});
+const win = TestBed.inject(WINDOW);
+win.location.reload();
+win.parent.postMessage('ready', '*');
+expect(spies.location.reload).toHaveBeenCalledOnce();
+expect(spies.parent.postMessage).toHaveBeenCalledWith('ready', '*');
+```
+
+Pass an array for root methods: `createWindowSpies(['close', 'focus'])`. Each call builds fresh spies.
+The object returned by `createWindowSpies` contains only the selected methods. Their parameter types and spy helpers are preserved.
+For methods that return a value, use `createFunctionSpy` and configure that value explicitly.
+When adding location values, spread `spies.location` too; replacing it would discard the reload spy.
+
 ### The Material dialog trio — `provideMatDialogData` / `provideMatDialogRef`
 
 ```ts

package/agent-docs/return-helpers.md

@@ -220,3 +220,11 @@ closures, not on the runner's mock. So when a spy outlives a test — a TestBed
 a spy hoisted to `describe` scope — put `resetAutoSpy(spy)` in `beforeEach`. Inside one test the
 sequence `nextWith(a)` then `throwWith(e)` still means "emit a, then fail"; only a reset or a
 terminal call starts a new stream.
+
+### Keeping an awaited collaborator pending
+
+`createDeferred<T>()` from the core entry returns `{ promise, resolve, reject }`. Return `promise`
+from the spy, start the operation, assert the intermediate state, then `resolve(value)` and await
+the operation. `createDeferred()` defaults to `void`; `resolve()` then needs no argument.
+Do not await the operation before resolving its dependency. No timer or `Promise.withResolvers`
+is required. Use the runner's core entry (`/bun`, `/node`, `/rstest`) outside Vitest.

package/agent-docs/waiting.md

@@ -22,6 +22,17 @@ fixture.debugElement.query(By.css('.open')).nativeElement.click(); // production
 await settleDynamicImport(() => import('./profile-select.modal'));
 ```
 
+**Loading provider classes is setup, not a wait for application work.** Keep
+`const { PremiumService } = await import('./premium.service')` when its exports configure Angular
+providers before creating the service under test. `settleDynamicImport` is useful after an action
+starts a lazy import; it adds no needed wait merely to read provider classes. Preserve dynamic
+imports when module evaluation order matters, including `vi.resetModules()` / `vi.doMock()` setup.
+The ESLint rule recognises provider setup in `beforeEach` / `beforeAll`. Earlier fixture factories
+must be imported functions whose bound results also supply providers. Member calls and other
+actions prevent this exemption, except recognised module-registry resets.
+
+`await Promise.resolve()` yields to microtasks; it is not equivalent to `flushEventLoop(1)`.
+
 Three rules worth stating outright, because each of them cost a day somewhere:
 
 - **`afterNextRender` does not run on `detectChanges()`.** A component that fills a form there is
@@ -30,9 +41,8 @@ Three rules worth stating outright, because each of them cost a day somewhere:
 - **`fixture.whenRenderingDone()` is not a stronger `whenStable()`.** With an animation renderer
   installed it degrades to `Promise.resolve()`. Use `stable(fixture)`.
 - **`fakeAsync` / `tick()` / `flushMicrotasks()` never reach the module loader.** Spinning
-  `await Promise.resolve()` ten times looks like it works and instead lands the continuation after
-  teardown — a green run with `NG0205: Injector has already been destroyed` in "Unhandled Errors"
-  and a non-zero exit code.
+  `await Promise.resolve()` ten times may leave a continuation until after teardown, causing
+  `NG0205: Injector has already been destroyed` in "Unhandled Errors" and a non-zero exit code.
 
 **`stable()` and `flushEffects()` are not zoneless-only, and their tick runs inside the `NgZone` so
 that they are not.** `TestBed.createComponent` builds the component inside `ngZone.run(…)`, so an

package/dist/angular-doubles.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { InjectionToken, AbstractType, Injector, ValueProvider, FactoryProvider, ProviderToken, ChangeDetectorRef } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-BdYUK_Zv.js';
+import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func, p as FunctionSpy } from './types-BdYUK_Zv.js';
 import { DomSanitizer } from '@angular/platform-browser';
 import 'vitest';
 
@@ -183,7 +183,7 @@ declare function injectMatDialogRef<Ref extends DialogRefLike>(RefClass: Abstrac
  */
 
 /** How many levels of slicing the type follows. Beyond it a member takes its whole type. */
-type Levels = [never, 0, 1, 2, 3];
+type Levels$1 = [never, 0, 1, 2, 3];
 /**
  * One member's override: the member's own type, or a slice of it wherever it is a plain-ish object.
  *
@@ -192,7 +192,7 @@ type Levels = [never, 0, 1, 2, 3];
  * array is matched whole too: slicing one by index describes nothing a spec means.
  */
 type PlatformOverride<V, Depth extends number> = V extends (...args: never[]) => unknown ? V : V extends readonly unknown[] ? V : V extends object ? Depth extends 0 ? V : V | {
-    [K in keyof V]?: PlatformOverride<V[K], Levels[Depth]>;
+    [K in keyof V]?: PlatformOverride<V[K], Levels$1[Depth]>;
 } : V;
 /**
  * What a spec says about a platform object: a value per member, and a **slice** wherever the member
@@ -470,4 +470,35 @@ declare function provideOverlayDouble<O extends OverlayLike>(OverlayClass: Abstr
  */
 declare function injectOverlayDouble<O extends OverlayLike>(OverlayClass: AbstractType<O>, injector?: Injector): OverlayDouble<O>;
 
-export { type AttachedComponent, type DialogComponent, type DialogDataOf, type DialogRefLike, type DialogResult, type MatDialogRefDouble, type MatDialogRefInit, type OverlayDouble, type OverlayDoubleInit, type OverlayLike, type OverlayRefDouble, type OverlayRefStub, type PlatformFlagTokens, type PlatformName, type PlatformOverrides, type PositionCall, createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };
+type Levels = [never, 0, 1, 2, 3];
+type VoidMethodKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: never[]) => infer R ? (R extends void ? K : never) : never;
+}[keyof T];
+/** Select void methods at each object level; only named methods become spies. */
+type WindowSpySelection<T = Window, Depth extends number = 3> = readonly VoidMethodKeys<T>[] | (Depth extends 0 ? never : {
+    [K in keyof T as T[K] extends object ? (T[K] extends (...args: never[]) => unknown ? never : K) : never]?: WindowSpySelection<NonNullable<T[K]>, Levels[Depth]>;
+});
+/** The selected methods, with their original call signatures and the auto-spy helpers. */
+type WindowSpies<T, Selection> = Selection extends readonly (infer K)[] ? {
+    [P in Extract<K, keyof T>]: T[P] extends (...args: never[]) => unknown ? FunctionSpy<T[P]> : never;
+} : {
+    [P in keyof Selection & keyof T]: WindowSpies<NonNullable<T[P]>, Selection[P]>;
+};
+type ValidSelection<T, Selection> = Selection extends readonly unknown[] ? readonly VoidMethodKeys<T>[] : {
+    [K in keyof Selection]: K extends keyof T ? T[K] extends (...args: never[]) => unknown ? never : ValidSelection<NonNullable<T[K]>, Selection[K]> : never;
+};
+/**
+ * Build typed, already configured no-op spies for selected void window methods.
+ *
+ * ```ts
+ * const spies = createWindowSpies({ location: ['reload'], parent: ['postMessage'] });
+ * provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'tv.kion.ru' } });
+ * expect(spies.location.reload).toHaveBeenCalledOnce();
+ * ```
+ *
+ * No global is read or patched. Pass the result to `createWindowDouble` or `provideWindowDouble`;
+ * unnamed members still use the real window. Use `createFunctionSpy` for methods returning values.
+ */
+declare function createWindowSpies<const Selection extends WindowSpySelection>(selection: Selection & ValidSelection<Window, Selection>): WindowSpies<Window, Selection>;
+
+export { type AttachedComponent, type DialogComponent, type DialogDataOf, type DialogRefLike, type DialogResult, type MatDialogRefDouble, type MatDialogRefInit, type OverlayDouble, type OverlayDoubleInit, type OverlayLike, type OverlayRefDouble, type OverlayRefStub, type PlatformFlagTokens, type PlatformName, type PlatformOverrides, type PositionCall, type WindowSpies, type WindowSpySelection, createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, createWindowSpies, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };

package/dist/angular-doubles.js

@@ -464,7 +464,35 @@ function injectOverlayDouble(OverlayClass, injector) {
   return double;
 }
 
+// src/lib/window-spies.ts
+function buildSpies(selection, path) {
+  const result = {};
+  if (Array.isArray(selection)) {
+    for (const key of selection) {
+      Object.defineProperty(result, key, {
+        value: createFunctionSpy(`${path}.${String(key)}`).mockReturnValue(void 0),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  } else {
+    for (const key of Reflect.ownKeys(selection)) {
+      Object.defineProperty(result, key, {
+        value: buildSpies(Reflect.get(selection, key), `${path}.${String(key)}`),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  return result;
+}
+function createWindowSpies(selection) {
+  return buildSpies(selection, "window");
+}
+
 // src/angular-doubles.ts
 useVitestAdapter();
 
-export { createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };
+export { createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, createWindowSpies, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };

package/dist/bun-angular.d.ts

@@ -1,5 +1,5 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/bun-angular.js

@@ -7,7 +7,7 @@ import { angularInternalsError } from './chunk-4JY7KIJG.js';
 import './chunk-VLEU3CWT.js';
 import { createSpyForToken } from './chunk-6KS7F4YM.js';
 export { createNestUnit } from './chunk-6KS7F4YM.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-YAAE5465.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-EFUZ44HT.js';
 import { mockValueProp } from './chunk-RQLUH6RE.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
 import { closestName } from './chunk-BCT7C6DQ.js';

package/dist/bun.d.ts

@@ -1,5 +1,5 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/bun.js

@@ -1,6 +1,6 @@
 import './chunk-VLEU3CWT.js';
 export { createNestUnit } from './chunk-6KS7F4YM.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-YAAE5465.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-EFUZ44HT.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
 export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BCT7C6DQ.js';
 import './chunk-SF4GKKN4.js';

package/dist/{chunk-YAAE5465.js → chunk-EFUZ44HT.js}

@@ -1097,6 +1097,17 @@ function createLog() {
   };
 }
 
+// src/lib/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
 // src/lib/with-overrides.ts
 function readableKeys(model) {
   const keys = new Set(Object.keys(model));
@@ -1408,4 +1419,4 @@ var adoptMock2 = defineHelper((mock, options = {}) => {
   return exposeAsAdopted(spy);
 });
 
-export { adoptMock2 as adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg2 as captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, mockConstructor2 as mockConstructor, mockDeep, moduleNamespace, narrow2 as narrow, outOfType, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides };
+export { adoptMock2 as adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg2 as captureArg, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, mockConstructor2 as mockConstructor, mockDeep, moduleNamespace, narrow2 as narrow, outOfType, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides };

package/dist/cli.js

@@ -1667,7 +1667,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.59.1";
+var EXPORT_MAP_VERSION = "5.62.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular/diagnostics vitest-auto-spy/angular/doubles vitest-auto-spy/angular/matchers vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin vitest-auto-spy/perf-reporter";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 20 21 22",
@@ -1775,6 +1775,7 @@ var EXPORTED_BY = {
   createAutoMock: "0 1 2 3 4 20 21 22",
   createChangeDetectorRefDouble: "14",
   createComponentStub: "12",
+  createDeferred: "0 1 2 3 4 20 21 22",
   createDirectiveHost: "12",
   createDocumentDouble: "14",
   createDomSanitizerDouble: "14",
@@ -1800,11 +1801,13 @@ var EXPORTED_BY = {
   createSpyFromInstance: "0 1 2 3 4 20 21 22",
   createSpyObj: "9",
   createWindowDouble: "14",
+  createWindowSpies: "14",
   createWithAutoSpies: "2 12",
   CreateWithAutoSpiesOptions: "2 12",
   DeepMockProxy: "0 1 2 3 4 20 21 22",
   DeepPartial: "0 1 2 3 4 20 21 22",
   default: "25 26",
+  Deferred: "0 1 2 3 4 20 21 22",
   describeDuplicateCopies: "0 1 2 3 4 20 21 22 23",
   describeStrayListeners: "23",
   describeStrayTimers: "23",
@@ -2158,6 +2161,8 @@ var EXPORTED_BY = {
   WebStorageKey: "7",
   WebStorageStub: "7",
   WebStorageStubOptions: "7",
+  WindowSpies: "14",
+  WindowSpySelection: "14",
   withFakeTimers: "23",
   WithMockReturnValue: "0 1 2 3 4 20 21 22",
   withoutStrayTimerTracking: "23",

package/dist/core.d.ts

@@ -855,6 +855,18 @@ interface CallLog<T extends string = string> {
  */
 declare function createLog<T extends string = string>(): CallLog<T>;
 
+/** A promise whose outcome the test controls after the application starts awaiting it. */
+interface Deferred<T> {
+    readonly promise: Promise<T>;
+    readonly resolve: (value: PromiseLike<T> | T) => void;
+    readonly reject: (reason?: unknown) => void;
+}
+/**
+ * Keep an async collaborator pending until the test has checked the intermediate state.
+ * Uses the Promise constructor, so it also works without `Promise.withResolvers`.
+ */
+declare function createDeferred<T = void>(): Deferred<T>;
+
 /**
  * A fixture built from a model instance, with some fields changed.
  *
@@ -1166,4 +1178,4 @@ type AdoptedMock<F extends Func> = AddSpyMethodsByReturnTypes<F extends MockInst
  */
 declare const adoptMock: <F extends Func>(mock: F, options?: AdoptMockOptions) => AdoptedMock<F>;
 
-export { AddSpyMethodsByReturnTypes, type AdoptMockOptions, type AdoptedMock, type ArgCaptor, type AsInstances, type AssertMockedOptions, type CallLog, type CaptureArgOptions, ClassSpyConfiguration, ClassType, type ConstructorMock, type ConstructorSpy, DeepMockProxy, DeepPartial, type FixtureFactory, type FlushUntilOptions, Func, InstanceSpyConfiguration, type MockDeepOptions, type ModuleNamespace, type ModuleNamespaceOptions, OnlyMethodKeysOf, Spy, type SpyClassOptions, SpyOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides };
+export { AddSpyMethodsByReturnTypes, type AdoptMockOptions, type AdoptedMock, type ArgCaptor, type AsInstances, type AssertMockedOptions, type CallLog, type CaptureArgOptions, ClassSpyConfiguration, ClassType, type ConstructorMock, type ConstructorSpy, DeepMockProxy, DeepPartial, type Deferred, type FixtureFactory, type FlushUntilOptions, Func, InstanceSpyConfiguration, type MockDeepOptions, type ModuleNamespace, type ModuleNamespaceOptions, OnlyMethodKeysOf, Spy, type SpyClassOptions, SpyOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides };

package/dist/eslint-plugin.cjs

@@ -480,13 +480,13 @@ function runnerBehind(callee) {
   }
   return isCallExpression(callee) ? runnerBehind(callee.callee) : void 0;
 }
-function insideRunnerCallback(node) {
+function enclosingRunner(node) {
   const callback = enclosingFunction(node);
   if (!callback) {
-    return false;
+    return void 0;
   }
   const call = callback.parent;
-  return isCallExpression(call) && call.arguments.includes(callback) && runnerBehind(call.callee) !== void 0;
+  return isCallExpression(call) && call.arguments.includes(callback) ? runnerBehind(call.callee) : void 0;
 }
 function consumptionOf(node) {
   const { parent } = node;
@@ -518,6 +518,74 @@ function takesTheNamespaceFirst(node, bound) {
   const before2 = siblings2.slice(0, siblings2.indexOf(statement)).reverse().find((sibling) => !bound.has(sibling));
   return before2 === void 0 ? statement.parent === callback.body : resetsRegistry(before2);
 }
+function providerReference(context, reference, callback) {
+  if (enclosingFunction(reference) !== callback) {
+    return false;
+  }
+  let current = reference;
+  while (current !== callback) {
+    if (propertyName(current) === "providers") {
+      const configuration = current.parent;
+      const call = configuration.parent;
+      if (!isCallExpression(call) || !call.arguments.includes(configuration)) {
+        return false;
+      }
+      if (!isMemberExpression(call.callee) || memberName(call.callee) !== "configureTestingModule" || !isIdentifier(call.callee.object)) {
+        return false;
+      }
+      const receiver = call.callee.object;
+      const binding = findBinding(context.sourceCode.getScope(receiver), receiver.name);
+      const specifier = binding && importSpecifierOf(binding);
+      return specifier ? isIdentifier(specifier.imported) && specifier.imported.name === "TestBed" && specifier.parent.source.value === "@angular/core/testing" : binding === void 0 && receiver.name === "TestBed";
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function suppliesProvider(context, awaited, callback) {
+  const holder = awaited.parent;
+  const pattern = isVariableDeclarator(holder) ? holder.id : isAssignmentExpression(holder) ? holder.left : void 0;
+  return pattern !== void 0 && anyInSubtree(
+    context,
+    pattern,
+    (candidate) => {
+      if (!isIdentifier(candidate)) {
+        return false;
+      }
+      const binding = findBinding(context.sourceCode.getScope(candidate), candidate.name);
+      const writes = binding?.references.filter((reference) => reference.writeExpr) ?? [];
+      return writes.length === 1 && writes[0]?.writeExpr === awaited && binding?.references.some(
+        (reference) => reference.identifier.range[0] > awaited.range[1] && providerReference(context, reference.identifier, callback)
+      ) === true;
+    },
+    false
+  );
+}
+function preparesProvider(context, call, callback) {
+  if (!isCallExpression(call) || !isIdentifier(call.callee)) {
+    return false;
+  }
+  const binding = findBinding(context.sourceCode.getScope(call), call.callee.name);
+  return binding?.defs.some((definition) => definition.type === "ImportBinding") === true && suppliesProvider(context, call, callback);
+}
+function loadsProviderForSetup(context, node, runner) {
+  const callback = enclosingFunction(node);
+  const statement = bindingStatement(node.parent);
+  if (!callback || statement?.parent !== callback.body || !isBlockStatement(callback.body)) {
+    return false;
+  }
+  if (runner !== "beforeAll" && runner !== "beforeEach" || !suppliesProvider(context, node.parent, callback)) {
+    return false;
+  }
+  return callback.body.body.slice(0, callback.body.body.indexOf(statement)).every(
+    (before2) => (before2.type === "VariableDeclaration" || isExpressionStatement(before2)) && !anyInSubtree(
+      context,
+      before2,
+      (candidate) => isAssignmentExpression(candidate) && !isIdentifier(candidate.left) || candidate.type === "UnaryExpression" && Reflect.get(candidate, "operator") === "delete" || (isCallExpression(candidate) || candidate.type === "NewExpression" || candidate.type === "AwaitExpression" || candidate.type === "UpdateExpression") && !preparesProvider(context, candidate, callback) && !(candidate.type === "AwaitExpression" && suppliesProvider(context, candidate, callback) && anyInSubtree(context, candidate, (child) => child.type === "ImportExpression" && child.parent === candidate, false)) && !isRunnerCall(candidate, REGISTRY_RESETS),
+      false
+    )
+  );
+}
 function wrap(context, node) {
   const state = bindingState(context.sourceCode.getScope(node), HELPER);
   if (state === "taken") {
@@ -540,7 +608,7 @@ var preferSettleDynamicImport = defineRule({
   description: "Load a module the code under test lazy-loads with settleDynamicImport(), not a bare await import()",
   hasSuggestions: true,
   messages: {
-    awaitedDynamicImport: `\`await {{load}}\` waits for the module, not for the code under test that was loading it: its continuation after its own \`await\` has not run yet, so the assertions below read the state one turn early. ${REPAIR}`,
+    awaitedDynamicImport: `\`await {{load}}\` waits for the module, not for the code under test that was loading it: its continuation after its own \`await\` may still be pending, so the assertions below may read state too early. ${REPAIR}`,
     thenedDynamicImport: `\`{{load}}.then(\u2026)\` waits for the module, not for the code under test that was loading it, and its callback runs later still, after the test ends if nothing awaits it. ${REPAIR}`
   },
   create: (context) => {
@@ -548,7 +616,8 @@ var preferSettleDynamicImport = defineRule({
     return {
       ImportExpression: (node) => {
         const consumption = consumptionOf(node);
-        if (consumption === void 0 || !insideRunnerCallback(node) || consumption === "await" && takesTheNamespaceFirst(node, bound)) {
+        const runner = enclosingRunner(node);
+        if (consumption === void 0 || runner === void 0 || consumption === "await" && (takesTheNamespaceFirst(node, bound) || loadsProviderForSetup(context, node, runner))) {
           return;
         }
         const messageId = consumption === "await" ? "awaitedDynamicImport" : "thenedDynamicImport";

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/index.js

@@ -4820,6 +4820,17 @@ function createLog() {
   };
 }
 
+// src/lib/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
 // src/lib/with-overrides.ts
 function readableKeys(model) {
   const keys = new Set(Object.keys(model));
@@ -5134,4 +5145,4 @@ var adoptMock2 = defineHelper((mock, options = {}) => {
 // vitest-auto-spy-host:index.ts
 useVitestAdapter();
 
-export { adoptMock2 as adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg2 as captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass2 as createSpyFromClass, createSpyFromInstance, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, innerDouble, mockAccessorsProp, mockConstructor2 as mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow2 as narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides, callSiteName as ɵauto_mock$callSiteName, PROXY_MIN_METHODS as ɵcreate_spy_from_class$PROXY_MIN_METHODS, applyConfiguredReturns as ɵcreate_spy_from_class$applyConfiguredReturns, applyReturns as ɵcreate_spy_from_class$applyReturns, classDoubles as ɵcreate_spy_from_class$classDoubles, getCallableMemberNames as ɵcreate_spy_from_class$getCallableMemberNames, mergeMethodNames as ɵcreate_spy_from_class$mergeMethodNames, resolveAccessors as ɵcreate_spy_from_class$resolveAccessors, resolveConfiguration as ɵcreate_spy_from_class$resolveConfiguration, rejectAsSourceError as ɵexpect_emission$rejectAsSourceError, subscribeAndCollect as ɵexpect_emission$subscribeAndCollect, timeoutError as ɵexpect_emission$timeoutError, unexpectedEmissionError as ɵexpect_emission$unexpectedEmissionError, fakeClockAdvice as ɵfake_clock_state$fakeClockAdvice, fakeClockBacklog as ɵfake_clock_state$fakeClockBacklog, adoptFunctionSpy as ɵfunction_spy$adoptFunctionSpy, defaultStrict as ɵfunction_spy$defaultStrict, ownDirectory as ɵfunction_spy$ownDirectory, reinstallDispatch as ɵfunction_spy$reinstallDispatch, resetLenientMissHint as ɵfunction_spy$resetLenientMissHint, resolveUnstubbedGuard as ɵfunction_spy$resolveUnstubbedGuard, seedReturnValue as ɵfunction_spy$seedReturnValue, setDefaultStrictMode as ɵfunction_spy$setDefaultStrictMode, takeStrictViolations as ɵfunction_spy$takeStrictViolations, DOCS as ɵmessage_link$DOCS, DOCS_RXJS as ɵmessage_link$DOCS_RXJS, withDocs as ɵmessage_link$withDocs, misconfigurationThrows as ɵmisconfiguration$misconfigurationThrows, reportMisconfiguration as ɵmisconfiguration$reportMisconfiguration, setMisconfigurationReaction as ɵmisconfiguration$setMisconfigurationReaction, beginPropEpoch as ɵprop_mock$beginPropEpoch, currentSpecFile as ɵspec_file$currentSpecFile, closestName as ɵspy_config_warnings$closestName, ownerOf as ɵspy_config_warnings$ownerOf, warnOnAccessorNamingAMethod as ɵspy_config_warnings$warnOnAccessorNamingAMethod, warnOnUnknownMethods as ɵspy_config_warnings$warnOnUnknownMethods, dropAutoSpyDefaults as ɵspy_defaults$dropAutoSpyDefaults, mergeAutoSpyDefaults as ɵspy_defaults$mergeAutoSpyDefaults, mergeRegisteredDefaults as ɵspy_defaults$mergeRegisteredDefaults, registerFrom as ɵspy_defaults$registerFrom, AUTO_SPY_MARK as ɵspy_mark$AUTO_SPY_MARK, DEEP_CHILDREN as ɵspy_mark$DEEP_CHILDREN, hooksOf as ɵspy_mark$hooksOf, isAutoSpyLike as ɵspy_mark$isAutoSpyLike, isMarkedMock as ɵspy_mark$isMarkedMock, markAsMock as ɵspy_mark$markAsMock, readDeepChildren as ɵspy_mark$readDeepChildren, runClearHook as ɵspy_mark$runClearHook, runConfigReset as ɵspy_mark$runConfigReset, unpatchedClearTimeout as ɵunpatched_timers$unpatchedClearTimeout, unpatchedSetTimeout as ɵunpatched_timers$unpatchedSetTimeout, unpatchedTimer as ɵunpatched_timers$unpatchedTimer, useVitestAdapter as ɵuse_vitest_adapter$useVitestAdapter };
+export { adoptMock2 as adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg2 as captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createDeferred, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass2 as createSpyFromClass, createSpyFromInstance, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, innerDouble, mockAccessorsProp, mockConstructor2 as mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow2 as narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides, callSiteName as ɵauto_mock$callSiteName, PROXY_MIN_METHODS as ɵcreate_spy_from_class$PROXY_MIN_METHODS, applyConfiguredReturns as ɵcreate_spy_from_class$applyConfiguredReturns, applyReturns as ɵcreate_spy_from_class$applyReturns, classDoubles as ɵcreate_spy_from_class$classDoubles, getCallableMemberNames as ɵcreate_spy_from_class$getCallableMemberNames, mergeMethodNames as ɵcreate_spy_from_class$mergeMethodNames, resolveAccessors as ɵcreate_spy_from_class$resolveAccessors, resolveConfiguration as ɵcreate_spy_from_class$resolveConfiguration, rejectAsSourceError as ɵexpect_emission$rejectAsSourceError, subscribeAndCollect as ɵexpect_emission$subscribeAndCollect, timeoutError as ɵexpect_emission$timeoutError, unexpectedEmissionError as ɵexpect_emission$unexpectedEmissionError, fakeClockAdvice as ɵfake_clock_state$fakeClockAdvice, fakeClockBacklog as ɵfake_clock_state$fakeClockBacklog, adoptFunctionSpy as ɵfunction_spy$adoptFunctionSpy, defaultStrict as ɵfunction_spy$defaultStrict, ownDirectory as ɵfunction_spy$ownDirectory, reinstallDispatch as ɵfunction_spy$reinstallDispatch, resetLenientMissHint as ɵfunction_spy$resetLenientMissHint, resolveUnstubbedGuard as ɵfunction_spy$resolveUnstubbedGuard, seedReturnValue as ɵfunction_spy$seedReturnValue, setDefaultStrictMode as ɵfunction_spy$setDefaultStrictMode, takeStrictViolations as ɵfunction_spy$takeStrictViolations, DOCS as ɵmessage_link$DOCS, DOCS_RXJS as ɵmessage_link$DOCS_RXJS, withDocs as ɵmessage_link$withDocs, misconfigurationThrows as ɵmisconfiguration$misconfigurationThrows, reportMisconfiguration as ɵmisconfiguration$reportMisconfiguration, setMisconfigurationReaction as ɵmisconfiguration$setMisconfigurationReaction, beginPropEpoch as ɵprop_mock$beginPropEpoch, currentSpecFile as ɵspec_file$currentSpecFile, closestName as ɵspy_config_warnings$closestName, ownerOf as ɵspy_config_warnings$ownerOf, warnOnAccessorNamingAMethod as ɵspy_config_warnings$warnOnAccessorNamingAMethod, warnOnUnknownMethods as ɵspy_config_warnings$warnOnUnknownMethods, dropAutoSpyDefaults as ɵspy_defaults$dropAutoSpyDefaults, mergeAutoSpyDefaults as ɵspy_defaults$mergeAutoSpyDefaults, mergeRegisteredDefaults as ɵspy_defaults$mergeRegisteredDefaults, registerFrom as ɵspy_defaults$registerFrom, AUTO_SPY_MARK as ɵspy_mark$AUTO_SPY_MARK, DEEP_CHILDREN as ɵspy_mark$DEEP_CHILDREN, hooksOf as ɵspy_mark$hooksOf, isAutoSpyLike as ɵspy_mark$isAutoSpyLike, isMarkedMock as ɵspy_mark$isMarkedMock, markAsMock as ɵspy_mark$markAsMock, readDeepChildren as ɵspy_mark$readDeepChildren, runClearHook as ɵspy_mark$runClearHook, runConfigReset as ɵspy_mark$runConfigReset, unpatchedClearTimeout as ɵunpatched_timers$unpatchedClearTimeout, unpatchedSetTimeout as ɵunpatched_timers$unpatchedSetTimeout, unpatchedTimer as ɵunpatched_timers$unpatchedTimer, useVitestAdapter as ɵuse_vitest_adapter$useVitestAdapter };

package/dist/node.cjs

@@ -4296,6 +4296,17 @@ function createLog() {
   };
 }
 
+// src/lib/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
 // src/lib/with-overrides.ts
 function readableKeys(model) {
   const keys = new Set(Object.keys(model));
@@ -4795,6 +4806,7 @@ exports.clearAutoSpyDefaults = clearAutoSpyDefaults;
 exports.countMockedProps = countMockedProps;
 exports.countNodeMocks = countNodeMocks;
 exports.createAutoMock = createAutoMock;
+exports.createDeferred = createDeferred;
 exports.createFixture = createFixture;
 exports.createFixtureFactory = createFixtureFactory;
 exports.createFunctionSpy = createFunctionSpy;

package/dist/node.d.cts

@@ -20,6 +20,7 @@ export declare const clearAutoSpyDefaults: typeof Entry.clearAutoSpyDefaults;
 export declare const countMockedProps: typeof Entry.countMockedProps;
 export declare const countNodeMocks: typeof Entry.countNodeMocks;
 export declare const createAutoMock: typeof Entry.createAutoMock;
+export declare const createDeferred: typeof Entry.createDeferred;
 export declare const createFixture: typeof Entry.createFixture;
 export declare const createFixtureFactory: typeof Entry.createFixtureFactory;
 export declare const createFunctionSpy: typeof Entry.createFunctionSpy;

package/dist/node.d.ts

@@ -1,5 +1,5 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/node.js

@@ -4164,6 +4164,17 @@ function createLog() {
   };
 }
 
+// src/lib/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
 // src/lib/with-overrides.ts
 function readableKeys(model) {
   const keys = new Set(Object.keys(model));
@@ -4649,4 +4660,4 @@ function createNestUnit(Target, options = {}) {
 registerMockAdapter(createNodeMockAdapter(createSwappableNodeTracker({ mock, afterEach })));
 registerRunnerHooks({ beforeEach, afterEach });
 
-export { adoptMock2 as adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg2 as captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, countNodeMocks, createAutoMock, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createNestUnit, createSpyClass, createSpyFromClass2 as createSpyFromClass, createSpyFromInstance, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, innerDouble, mockAccessorsProp, mockConstructor2 as mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow2 as narrow, outOfType, pruneNodeMocks, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, trackNodeMocks, withOverrides };
+export { adoptMock2 as adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg2 as captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, countNodeMocks, createAutoMock, createDeferred, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createNestUnit, createSpyClass, createSpyFromClass2 as createSpyFromClass, createSpyFromInstance, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, innerDouble, mockAccessorsProp, mockConstructor2 as mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow2 as narrow, outOfType, pruneNodeMocks, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, trackNodeMocks, withOverrides };

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/react.js

@@ -1,5 +1,5 @@
 import { ɵuse_vitest_adapter$useVitestAdapter as _use_vitest_adapter$useVitestAdapter } from './index.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, describeDuplicateCopies, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, innerDouble, mockAccessorsProp, mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './index.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createDeferred, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, describeDuplicateCopies, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, innerDouble, mockAccessorsProp, mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './index.js';
 
 // vitest-auto-spy-host-reexport:src/lib/use-vitest-adapter.ts
 

package/dist/rstest.d.ts

@@ -1,5 +1,5 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/rstest.js

@@ -1,4 +1,4 @@
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-YAAE5465.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-EFUZ44HT.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
 export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BCT7C6DQ.js';
 import './chunk-SF4GKKN4.js';

package/dist/svelte.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/svelte.js

@@ -1,5 +1,5 @@
 import { ɵuse_vitest_adapter$useVitestAdapter as _use_vitest_adapter$useVitestAdapter } from './index.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, describeDuplicateCopies, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, innerDouble, mockAccessorsProp, mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './index.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createDeferred, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, describeDuplicateCopies, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, innerDouble, mockAccessorsProp, mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './index.js';
 
 // vitest-auto-spy-host-reexport:src/lib/use-vitest-adapter.ts
 

package/dist/vue.d.ts

@@ -1,7 +1,7 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { S as Spy, m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf } from './types-BdYUK_Zv.js';
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
-export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
+export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, Deferred, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createDeferred, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
 export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/vue.js

@@ -1,5 +1,5 @@
 import { ɵuse_vitest_adapter$useVitestAdapter as _use_vitest_adapter$useVitestAdapter, createSpyFromClass } from './index.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, describeDuplicateCopies, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, innerDouble, mockAccessorsProp, mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './index.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, autoMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, countMockedProps, createAutoMock, createDeferred, createFixture, createFixtureFactory, createFunctionSpy, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, describeDuplicateCopies, errorHandler, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, innerDouble, mockAccessorsProp, mockConstructor, mockDeep, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, moduleNamespace, narrow, outOfType, registerAutoSpyDefaults, reportPropsOutsideHooks, resetAutoSpy, restoreMockedProps, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './index.js';
 
 // vitest-auto-spy-host-reexport:src/lib/use-vitest-adapter.ts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.60.0",
+  "version": "5.63.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",

package/skills/vitest-auto-spy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: vitest-auto-spy
-description: Typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports vitest-auto-spy or a subpath (/angular, /angular/*, /signal-forms, /bun-angular, /bun, /node, /rstest, /rxjs, /diagnostics, /nestjs, /jasmine, /setup, /zone, /eslint-plugin), naming createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, stubResponse, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, provideLocationDouble, collectRouterEvents, createLog, createComponentStub, createForm, toHaveFieldErrors, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, adoptMock, spyOnOwnMethod, spyOnVoidMethod, explainSpy, compareTestRuns, expectEmission, setupAutoSpy, setSpyEngine, assertMocked, calledWith, mustBeCalledWith, captureArg, ArgumentCaptor, onlyMethodsToSpyOn, onUnstubbedCall, passthrough, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator, or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not a method of", "strict double has nothing configured", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
+description: Typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports vitest-auto-spy (/angular, /angular/*, /signal-forms, /bun-angular, /bun, /node, /rstest, /rxjs, /diagnostics, /nestjs, /jasmine, /setup, /zone, /eslint-plugin), naming createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, createWindowSpies, provideHttpTesting, expectRequest, stubResponse, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, provideLocationDouble, collectRouterEvents, createLog, createComponentStub, createForm, toHaveFieldErrors, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, adoptMock, spyOnOwnMethod, spyOnVoidMethod, explainSpy, compareTestRuns, expectEmission, setupAutoSpy, setSpyEngine, assertMocked, calledWith, mustBeCalledWith, captureArg, ArgumentCaptor, onlyMethodsToSpyOn, onUnstubbedCall, passthrough, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator, or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not a method of", "strict double has nothing configured", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
 ---
 
 # vitest-auto-spy
@@ -216,6 +216,7 @@ it('loads', async () => {
 | a `vi.mock` factory's `vi.fn()` needs `calledWith` / `resolveWith`                                         | `adoptMock(api.load).calledWith(7).resolveWith(…)` — same object, history kept                                                                                                                                                                                                                                                                            |
 | real module, one case configured                                                                           | `vi.mock('x', async (orig) => moduleNamespace(await orig(), { passthrough: true }))`                                                                                                                                                                                                                                                                      |
 | feeding a stubbed `fetch`                                                                                  | `vi.fn(async () => stubResponse({ body: data }))` from `/setup` — a real `Response`, no `as Response`; a body reads once                                                                                                                                                                                                                                  |
+| an awaited dependency must stay pending while the test checks intermediate state                           | `createDeferred<T>()` from the core entry — return `.promise` from the spy, then `.resolve(value)` or `.reject(reason)` before awaiting the operation                                                                                                                                                                                                     |
 | a backend that answers the JSON literal `null`                                                             | `stubResponse({ body: null })` — the literal, not "no body"; `undefined` or an omitted `body` is the way to send none                                                                                                                                                                                                                                     |
 | the code under test lazy-loads on a click and the spec has no promise                                      | `await settleDynamicImport(() => import('./thing'))` — a bare `await import(…)` waits for the module, not for the handler's continuation                                                                                                                                                                                                                  |
 | MSW handlers not answering under `setupAutoSpy({ blockNetwork: true })`                                    | upgrade — `blockNetwork` now leaves `fetch` to MSW's interceptor; end the handlers with `http.all('*', () => HttpResponse.error())`                                                                                                                                                                                                                       |
@@ -329,11 +330,17 @@ it('loads', async () => {
 | a component that reads `location.back()`, or asserts where a redirect landed                               | `provideLocationDouble()` + `injectLocationDouble()` — Angular's own `SpyLocation`; without the provider, `Location` is `providedIn: 'root'` and the real one answers                                                                                                                                                                                     |
 | "did A run before B?" across three collaborators                                                           | `createLog<'drop-cache' \| 'flush'>()` — hand `log.fn('drop-cache')` to each, assert `log.result()` once                                                                                                                                                                                                                                                  |
 | a `window` or `document` behind a DI token                                                                 | `provideWindowDouble(WINDOW, { screen })` / `provideDocumentDouble({ … })` — `/angular/doubles`                                                                                                                                                                                                                                                           |
+| selected void window methods, such as `location.reload` or `parent.postMessage`                            | `createWindowSpies({ location: ['reload'], parent: ['postMessage'] })` from `/angular/doubles` — pass the result to `provideWindowDouble(WINDOW, spies)`; each spy returns `undefined` without calling the browser. For root methods, use `createWindowSpies(['close', 'focus'])`.                                                                        |
 | `MAT_DIALOG_DATA` and `MatDialogRef` provided by hand                                                      | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(MatDialogRef)` + `injectMatDialogRef(Ref)` — `/angular/doubles`                                                                                                                                                                                                                                |
 | asserting a `computed()` did **not** recompute                                                             | `trackRecomputations(sig)` / `trackEffectRuns(ref)` — `{ count, stop() }`                                                                                                                                                                                                                                                                                 |
 | `form()` in a spec, or `errors()` read by hand                                                             | `createForm(model, schema)` + `registerFormMatchers()` — then `toHaveFieldErrors([…])` (`/signal-forms`)                                                                                                                                                                                                                                                  |
 | any of those doubles without a `TestBed`                                                                   | `createRouterDouble` (`/angular-router`) / `createWindowDouble` / `createDocumentDouble` / `createMatDialogRef` (`/angular/doubles`)                                                                                                                                                                                                                      |
 
+When composing window spies with data overrides, keep the nested spies too:
+`provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'example.test' } })`.
+Assert calls on `spies.location.reload` or `spies.parent.postMessage`. For methods returning a value,
+use `createFunctionSpy` from the core and configure that value explicitly.
+
 ## Rules that prevent most of the mistakes
 
 - Declare the variable as **`Spy<T>`, never as `T`** — `Spy<T>` is a mapped type and drops private