vitest-auto-spy 3.6.0 → 3.7.0

package/AGENTS.md

@@ -1067,6 +1067,7 @@ mechanisms, and a test that waits on the wrong one fails with a message that nam
 | effects + `afterNextRender` + CD              | `await stable(fixture)` (`…/angular`)              | `detectChanges()` alone                   |
 | timers, debounces, polling                    | `await advanceTimers(ms)` (`…/setup`)              | `await Promise.resolve()`                 |
 | a dynamic `import()`, native `async` in a dep | `await flushEventLoop()` / `settleDynamicImport()` | `tick()`, `flushMicrotasks()`, microtasks |
+| an `httpResource()` / `resource()` / `rxResource` | `await settleResource(r)` (`…/angular`) | `flushEventLoopUntil` — it never ticks |
 
 ```ts
 import { flushEventLoop, settleDynamicImport } from 'vitest-auto-spy';
@@ -1088,9 +1089,14 @@ Three rules worth stating outright, because each of them cost a day somewhere:
   and a non-zero exit code.
 
 `flushEventLoopUntil(isDone, { turns, label })` is the same thing with a condition and a budget —
-for a `resource()` leaving `loading`, a chunk becoming reachable, an SDK reporting itself ready. Use
-it instead of a hand-tuned turn count: the count depends on the dependency, not on the spec, and a
-condition that never holds fails naming the `label` rather than hanging until the runner's timeout.
+for a chunk becoming reachable, an SDK reporting itself ready, a queue draining. Use it instead of a
+hand-tuned turn count: the count depends on the dependency, not on the spec, and a condition that
+never holds fails naming the `label` rather than hanging until the runner's timeout.
+
+**Not for an Angular `resource()` / `httpResource()`.** Those need a change-detection _tick_, and
+this helper only takes event-loop turns — a resource awaited through it finishes the whole budget
+having issued zero requests. `settleResource(resource, { turns, label })` from
+`vitest-auto-spy/angular` is that wait.
 
 `flushEventLoop(turns?)` takes real event-loop turns even while the timers are faked, without
 touching the clock. It is the honest name for the `await vi.advanceTimersByTimeAsync(0)` trick,
@@ -1474,9 +1480,15 @@ spies.get(PricingService).total.mockReturnValue(100);
 // NOTE: Injector.create() — it does NOT accept EnvironmentProviders (provideHttpClient() etc.)
 
 // zoneless waiting
-await stable(fixture); // flush effects, then await the fixture
+await stable(fixture); // flush effects, then await the fixture; fails at 2000 ms naming the cause
+await stable(fixture, { timeout: 5000, label: 'the products fixture' });
 flushEffects(); // the no-fixture half: services, stores, runInInjectionContext
 
+// resources — one wait for httpResource(), resource() and rxResource()
+flushEffects(); // an httpResource issues NO request until something ticks
+httpTesting.expectOne('/api/products').flush([product]);
+await settleResource(products, { label: 'the product resource' });
+
 // signal assertions
 registerSignalMatchers(); // once, in the setup file
 expect(component.total).toHaveSignalValue(3);
@@ -1489,6 +1501,12 @@ Two zoneless traps:
 - `expect(someSignal).toBeTruthy()` passes for **every** signal ever created — a signal is a
   function. Use `toHaveSignalValue`, which also rejects the missing-parentheses mistake.
 
+And one resource trap, which is the same shape one level up: an `httpResource()` reports `loading`
+with its **default** value until a tick _and_ a microtask after its response is flushed, so a spec
+that asserts too early asserts the default and passes. `settleResource` fails instead of passing
+emptily. Note the order — `flushEffects()` first (the request is issued there, not on creation),
+then the flush, then the wait.
+
 Per-file timing, to find which specs actually pay for `TestBed`:
 
 ```ts
@@ -1802,7 +1820,9 @@ packages, which a subpath export can never be.
 | a stub that works in the first test of the file and in no other                      | installed at `describe` level or in `beforeAll`, then restored away    | install it in `beforeEach`, or `installPerTest(() => stub…())`                              |
 | a third-party library failing every other run, no test named                         | a test sealed a global with `Object.defineProperty` (non-configurable) | `setupAutoSpy({ guardGlobals: 'throw' })` names the file; then `mockValueProp`              |
 | `expected [ { at: 1, …(5) }, …(8) ] to deeply equal [ { …(6) }, … ]`                 | one field moved in every element — usually a frozen clock or an id     | `expect(diffByField(actual, expected)).toBeUndefined()`                                     |
-| a hand-tuned number of turns waiting for a `resource()` to load                      | the hand-off count depends on the dependency, not on the spec          | `await flushEventLoopUntil(() => r.status() !== 'loading', { label })`                      |
+| a hand-tuned number of turns waiting for a `resource()` to load | a resource needs a change-detection **tick**, not event-loop turns; `flushEventLoopUntil` never ticks and the resource never even issues its request | `flushEffects()`, flush the request, then `await settleResource(r, { label })` |
+| a `resource()` assertion that passes but reads the **default** value | the spec asserted before the resource left `loading` | `await settleResource(r, { label })` — it fails loudly instead |
+| a spec dying on the runner's 5 s file timeout right after `await stable(fixture)` | the fixture never stabilised — an unflushed request, a real `setInterval` | `stable` now fails at 2000 ms naming the cause; raise `{ timeout }` only once neither is true |
 | `flushEventLoopUntil` timing out on the **first** such test only, the rest green | a cold dynamic `import()` outran the turn budget; later tests hit the module cache | `await settleDynamicImport(() => import('…'))` — await the module, do not count turns |
 | a template error in a `describe` that never patched anything                          | a spec `afterEach` threw and skipped `setupAutoSpy`'s, so a `mock*Prop` patch travelled | upgrade — an `onTestFinished` net restores it and names the cause (§10)                    |
 | `Property 'mockReturnValue' does not exist on type 'never'`                          | a generic method with a conditional return type; the spy collapsed     | upgrade — fixed in the types; the member now keeps its sync helper bundle                   |

package/README.md

@@ -16,7 +16,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 [![npm version](https://img.shields.io/npm/v/vitest-auto-spy?color=brightgreen&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![npm downloads](https://img.shields.io/npm/dm/vitest-auto-spy?color=brightgreen&logo=npm)](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-12.5%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-12.7%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)
@@ -48,7 +48,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 - 📡 First-class RxJS `Observable` spying (`nextWith`, `nextWithValues`, `throwWith`, …)
 - ⚙️ Getter / setter spies via `accessorSpies`
 - 🧰 DI & mocking utilities — `provideAutoSpy` / `injectSpy` (Angular, NestJS, Vue), `createFunctionSpy`, `mockReadonlyProp` for signals
-- ⚡ Angular speed & zoneless helpers — `renderShallow` (**1.7×** on real component specs), `createWithAutoSpies`, `stable` / `flushEffects`, `toHaveSignalValue`, per-file `TestBed` timings
+- ⚡ Angular speed & zoneless helpers — `renderShallow` (**1.7×** on real component specs), `createWithAutoSpies`, `stable` / `flushEffects`, `settleResource` for `httpResource()`, `toHaveSignalValue`, per-file `TestBed` timings
 - 🧱 The providers a testing module cannot reach — `overrideComponentProvider`, `provideAutoSpyForToken`, `assertNgModuleScopes`, `createDirectiveHost`
 - 📡 Observable assertions that fail on silence — `expectEmission` / `expectEmissions` / `expectNoEmission` / `expectCompletion` / `expectError`, no rxjs required, Angular `output()` included
 - 🏗️ Doubles for what the code builds itself — `mockConstructor` / `stubConstructor` for `new`, plus `stubMediaElement`, `stubAbortController` and the observer stubs
@@ -112,6 +112,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
     - [Shallow component rendering](#shallow-component-rendering)
     - [Building a class with auto-spied dependencies](#building-a-class-with-auto-spied-dependencies)
     - [Zoneless waiting](#zoneless-waiting)
+    - [Settling a `resource()` or `httpResource()`](#settling-a-resource-or-httpresource)
     - [Asserting a signal's value](#asserting-a-signals-value)
     - [Where a spec spends its time](#where-a-spec-spends-its-time)
   - [NestJS](#nestjs)
@@ -711,7 +712,7 @@ Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runti
 | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | :----: |
 | `vitest-auto-spy`               | `createSpyFromClass`, `createAutoMock`, `createFunctionSpy`, sync + promise + accessor spies, `errorHandler`, types                                           | `vitest`                    |   ✅   |
 | `vitest-auto-spy/rxjs`          | observable spies (`nextWith`, `nextWithValues`, `observablePropsToSpyOn`, …) + `createObservableWithValues`                                                   | `rxjs`                      |   ✅   |
-| `vitest-auto-spy/angular`       | `provideAutoSpy`, `injectSpy`, `renderShallow`, `createWithAutoSpies`, `stable`/`flushEffects`, the `mock*Prop` helpers, signal matchers, TestBed diagnostics | `@angular/core`             |   ✅   |
+| `vitest-auto-spy/angular`       | `provideAutoSpy`, `injectSpy`, `renderShallow`, `createWithAutoSpies`, `stable`/`flushEffects`, `settleResource`, the `mock*Prop` helpers, signal matchers, TestBed diagnostics | `@angular/core`             |   ✅   |
 | `vitest-auto-spy/bun`           | the same core, driven by Bun's `bun:test` mocks                                                                                                               | `bun:test`                  |   ✅   |
 | `vitest-auto-spy/bun-angular`   | Angular's `TestBed` under `bun test` — DOM, JIT `templateUrl` resolution and a zoneless environment, from one preload                                         | `bun:test`, `@angular/core` |   ✅   |
 | `vitest-auto-spy/node`          | the same core, driven by `node:test`'s `mock.fn()`                                                                                                            | `node:test`                 |   ✅   |
@@ -1255,6 +1256,35 @@ app the state that matters is signal-derived and effects are what move it forwar
 both, in the right order; `flushEffects` prefers `TestBed.tick()` (Angular ≥ 20) and falls back to
 `ApplicationRef.tick()`.
 
+The wait is bounded: `stable` gives the fixture **2000 ms** and then throws the cause, instead of
+letting the runner report a 5 s file-level timeout that names neither the helper nor the fixture.
+Pass `{ timeout, label }` to change either; `{ timeout: 0 }` waits indefinitely. The watchdog runs
+on a timer captured at import, so `vi.useFakeTimers()` cannot freeze it.
+
+#### Settling a `resource()` or `httpResource()`
+
+```ts
+import { flushEffects, settleResource } from 'vitest-auto-spy/angular';
+
+const products = TestBed.runInInjectionContext(() => httpResource<Product[]>(() => '/api/products'));
+
+flushEffects(); // the request is issued here — not when the resource was created
+TestBed.inject(HttpTestingController).expectOne('/api/products').flush([product]);
+await settleResource(products, { label: 'the product resource' });
+
+expect(products.value()).toEqual([product]);
+```
+
+Angular's resource primitives need a **different wait each** — measured on 21.2.17, an
+`httpResource` settles one tick + one microtask after its flush, a plain `resource()` takes two
+rounds of the same, and neither has made a request at all until something ticks. Getting it wrong
+asserts against the resource's _default_ value, which is a green test proving nothing.
+`settleResource` is the loop both converge under, with a turn budget and a failure that names the
+resource and the flush it is missing.
+
+`flushEventLoopUntil` cannot do this: it takes real event-loop turns and never ticks, so a resource
+awaited through it finishes the budget having issued zero requests.
+
 #### Asserting a signal's value
 
 ```ts
@@ -1931,7 +1961,8 @@ Both are the same object at runtime; only the view changes.
 | `describeDuplicateCopies()` / `getPackageCopies()`                                                           | The duplicate-install report, and the copies behind it                                                                                              |
 | `renderShallow(Component, opts?)` _(Angular)_                                                                | `TestBed` component, minus its children and (by default) its template                                                                               |
 | `createWithAutoSpies(Class, opts?)` _(Angular)_                                                              | Build a class through Angular DI with every unprovided token auto-spied                                                                             |
-| `stable(fixture)` / `flushEffects()` _(Angular)_                                                             | Zoneless waiting: flush effects, then await the fixture                                                                                             |
+| `stable(fixture, opts?)` / `flushEffects()` _(Angular)_                                                      | Zoneless waiting: flush effects, then await the fixture, with a 2 s budget that names the cause                                                      |
+| `settleResource(resource, opts?)` _(Angular)_                                                                | Tick until an `httpResource()` / `resource()` / `rxResource()` leaves `loading`                                                                      |
 | `registerSignalMatchers()` _(Angular)_                                                                       | Adds `expect(sig).toHaveSignalValue(value)`                                                                                                         |
 | `enableTestBedDiagnostics(opts?)` _(Angular)_                                                                | Per-file report of how much of a spec's time went into `TestBed`                                                                                    |
 | `setupAngularTestEnv(opts)` _(Angular)_                                                                      | Zone and zoneless spec files in one worker, switching platforms per file                                                                            |

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-export { g as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, S as ShallowRender, c as SpyRegistry, d as createWithAutoSpies, f as flushEffects, i as injectSpy, p as provideAutoSpy, h as provideAutoSpyForToken, r as renderShallow, e as runEffect, s as stable } from './run-effect-C_7mFldc.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-DbVZ96iR.js';
 import { Type, Signal, WritableSignal } from '@angular/core';
 import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-dZUFYsox.js';
 export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-CKFksCvA.js';

package/dist/angular.js

@@ -1,11 +1,11 @@
 import { useVitestAdapter } from './chunk-DMSELR3S.js';
-export { createWithAutoSpies, flushEffects, injectSpy, provideAutoSpy, provideAutoSpyForToken, renderShallow, runEffect, stable } from './chunk-F3NMY5KU.js';
+export { createWithAutoSpies, flushEffects, injectSpy, provideAutoSpy, provideAutoSpyForToken, renderShallow, runEffect, settleResource, stable } from './chunk-TMO2UFLD.js';
 import './chunk-OS2QFTIF.js';
-export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './chunk-QGZRH5XG.js';
+export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './chunk-2PFOBMTZ.js';
 import { mockReadonlyProp } from './chunk-QGBNXDKU.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-QGBNXDKU.js';
-import { createSpyFromClass } from './chunk-RJJJTLQ3.js';
-import './chunk-OEQTH7RA.js';
+import { createSpyFromClass } from './chunk-DNHLQG45.js';
+import './chunk-WT75WGQZ.js';
 import './chunk-TNB3Y3GI.js';
 import './chunk-DA5E36HQ.js';
 import { withDocs, DOCS_LINKS } from './chunk-VR5GJRBS.js';

package/dist/bun-angular.d.ts

@@ -3,7 +3,7 @@ export { AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, Flus
 export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-RtR1iYgI.js';
 export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-CKFksCvA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, S as ShallowRender, c as SpyRegistry, d as createWithAutoSpies, f as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, e as runEffect, s as stable } from './run-effect-C_7mFldc.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-DbVZ96iR.js';
 import 'rxjs';
 import 'vitest';
 import '@angular/core';

package/dist/bun-angular.js

@@ -1,11 +1,11 @@
-export { createWithAutoSpies, flushEffects, injectSpy, provideAutoSpy, renderShallow, runEffect, stable } from './chunk-F3NMY5KU.js';
+export { createWithAutoSpies, flushEffects, injectSpy, provideAutoSpy, renderShallow, runEffect, settleResource, stable } from './chunk-TMO2UFLD.js';
 import './chunk-OWQR2YVQ.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, clearAutoSpy, compareTestRuns, createMock, createSpyClass, diffByField, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-LSDPJMNS.js';
-export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './chunk-QGZRH5XG.js';
+export { asInstance, asInstances, asSpy, assertMocked, clearAutoSpy, compareTestRuns, createMock, createSpyClass, diffByField, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-R5MFTE64.js';
+export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './chunk-2PFOBMTZ.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-QGBNXDKU.js';
-export { autoMocked, createAutoMock, createSpyFromClass } from './chunk-RJJJTLQ3.js';
-export { createFunctionSpy, errorHandler } from './chunk-OEQTH7RA.js';
+export { autoMocked, createAutoMock, createSpyFromClass } from './chunk-DNHLQG45.js';
+export { createFunctionSpy, errorHandler } from './chunk-WT75WGQZ.js';
 import './chunk-TNB3Y3GI.js';
 export { describeDuplicateCopies, getPackageCopies } from './chunk-DA5E36HQ.js';
 import { withDocs, DOCS_LINKS } from './chunk-VR5GJRBS.js';

package/dist/bun.d.ts

@@ -444,8 +444,9 @@ declare function stubConstructor<T, TArgs extends unknown[] = unknown[]>(target:
  * Give the runtime `turns` real event-loop turns, whatever the timers are doing.
  *
  * Reach for it when the thing being awaited crosses out of the zone / out of the test's own
- * promise chain: a dynamic `import()` triggered by production code, an Angular `httpResource()` /
- * `resource()` delivering its first value, a native `async` function inside a dependency.
+ * promise chain: a dynamic `import()` triggered by production code, a native `async` function
+ * inside a dependency, a stub that resolves a turn later. Not an Angular `httpResource()` /
+ * `resource()` — those need a *tick*, which is `settleResource()`, not this.
  *
  * ```ts
  * component.openModal();          // production code does `await import('./modal')`
@@ -472,19 +473,25 @@ interface FlushUntilOptions {
 /**
  * Take real event-loop turns until `isDone()` says so, then stop — or fail saying it never did.
  *
- * The shape behind every hand-rolled "settle" helper: an Angular `httpResource()` / `resource()` /
- * `rxResource` leaving `loading`, a lazily-loaded chunk becoming reachable, an SDK reporting itself
- * ready. Written by hand it is a fixed number of turns, tuned by trial until the suite goes green —
- * which is both slower than it needs to be (it always waits the maximum) and quietly fragile (one
- * more hand-off in a dependency and the number is wrong again).
+ * The shape behind every hand-rolled "settle" helper: a lazily-loaded chunk becoming reachable, an
+ * SDK reporting itself ready, a queue draining. Written by hand it is a fixed number of turns, tuned
+ * by trial until the suite goes green — which is both slower than it needs to be (it always waits
+ * the maximum) and quietly fragile (one more hand-off in a dependency and the number is wrong
+ * again).
  *
  * ```ts
- * const products = TestBed.runInInjectionContext(() => httpResource(() => '/api/products'));
+ * client.warmUp();
  *
- * await flushEventLoopUntil(() => products.status() !== 'loading', { label: 'the product resource' });
- * expect(products.value()).toEqual([product]);
+ * await flushEventLoopUntil(() => client.isReady(), { label: 'the SDK handshake' });
+ * expect(client.session()).toBeDefined();
  * ```
  *
+ * **Not for an Angular resource** — use `settleResource()` from `vitest-auto-spy/angular` for that.
+ * This helper takes real event-loop turns and never *ticks*, and an `httpResource()` issues no
+ * request at all until something does: measured, a resource awaited here finishes the whole budget
+ * having made zero requests, then fails saying the condition was never met. The docstring used to
+ * claim that use case and show it as the example; it never worked.
+ *
  * The budget is what separates this from a `while (true)`: a condition that never becomes true is
  * the normal way for this to be used wrongly — the request was never made, the stub never resolved
  * — and a test that hangs until the runner's timeout reports the file, not the wait.

package/dist/bun.js

@@ -1,10 +1,10 @@
 import './chunk-OWQR2YVQ.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, clearAutoSpy, compareTestRuns, createMock, createSpyClass, diffByField, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-LSDPJMNS.js';
-export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './chunk-QGZRH5XG.js';
+export { asInstance, asInstances, asSpy, assertMocked, clearAutoSpy, compareTestRuns, createMock, createSpyClass, diffByField, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-R5MFTE64.js';
+export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './chunk-2PFOBMTZ.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-QGBNXDKU.js';
-export { autoMocked, createAutoMock, createSpyFromClass } from './chunk-RJJJTLQ3.js';
-export { createFunctionSpy, errorHandler } from './chunk-OEQTH7RA.js';
+export { autoMocked, createAutoMock, createSpyFromClass } from './chunk-DNHLQG45.js';
+export { createFunctionSpy, errorHandler } from './chunk-WT75WGQZ.js';
 import './chunk-TNB3Y3GI.js';
 export { describeDuplicateCopies, getPackageCopies } from './chunk-DA5E36HQ.js';
 import './chunk-VR5GJRBS.js';

package/dist/{chunk-QGZRH5XG.js → chunk-2PFOBMTZ.js}

@@ -1,4 +1,4 @@
-import { serializeValue } from './chunk-OEQTH7RA.js';
+import { serializeValue } from './chunk-WT75WGQZ.js';
 
 // src/lib/expect-emission.ts
 function subscribeToSource(source$, observer) {

package/dist/{chunk-RJJJTLQ3.js → chunk-DNHLQG45.js}

@@ -1,4 +1,4 @@
-import { AUTO_SPY_MARK, createFunctionSpy, markAsMock } from './chunk-OEQTH7RA.js';
+import { AUTO_SPY_MARK, createFunctionSpy, markAsMock } from './chunk-WT75WGQZ.js';
 import { requireObservableSupport } from './chunk-TNB3Y3GI.js';
 import { getMockAdapter } from './chunk-DA5E36HQ.js';
 import { withDocs, DOCS_LINKS } from './chunk-VR5GJRBS.js';

package/dist/{chunk-LSDPJMNS.js → chunk-R5MFTE64.js}

@@ -1,6 +1,6 @@
 import { mockValueProp, mockReadonlyPropGetter } from './chunk-QGBNXDKU.js';
-import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, isProtocolKey, isDeletedProp } from './chunk-RJJJTLQ3.js';
-import { runClearHook, runConfigReset, createFunctionSpy, isMarkedMock, serializeValue } from './chunk-OEQTH7RA.js';
+import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, isProtocolKey, isDeletedProp } from './chunk-DNHLQG45.js';
+import { runClearHook, runConfigReset, createFunctionSpy, isMarkedMock, readDeepChildren, serializeValue, DEEP_CHILDREN } from './chunk-WT75WGQZ.js';
 import { getMockAdapter } from './chunk-DA5E36HQ.js';
 import { withDocs, DOCS_LINKS } from './chunk-VR5GJRBS.js';
 
@@ -38,34 +38,43 @@ function readSpyMember(target, key, receiver, boundSpyMethods) {
   boundSpyMethods.set(key, bound);
   return bound;
 }
+function readNodeMember(state, target, key, receiver) {
+  const patched = readStoredAccessor(state.store, key, receiver);
+  if (patched !== NOT_STORED) {
+    return patched;
+  }
+  if (state.store.values.has(key)) {
+    return state.store.values.get(key);
+  }
+  if (key === DEEP_CHILDREN) {
+    return state.children;
+  }
+  if (key === "then" || isProtocolKey(key)) {
+    return void 0;
+  }
+  if (getSpySurfaceKeys().has(key)) {
+    return readSpyMember(target, key, receiver, state.boundSpyMethods);
+  }
+  if (typeof key === "symbol" || isDeletedProp(state.store, key)) {
+    return void 0;
+  }
+  if (!state.children.has(key)) {
+    state.children.set(key, createDeepNode(`${state.name}.${String(key)}`, {}, state.selfReturning));
+  }
+  return state.children.get(key);
+}
 function createDeepNode(name, overrides, selfReturning) {
   const spy = createFunctionSpy(name);
-  const children = /* @__PURE__ */ new Map();
-  const boundSpyMethods = /* @__PURE__ */ new Map();
-  const store = createProxyPropStore(overrides);
+  const state = {
+    name,
+    selfReturning,
+    children: /* @__PURE__ */ new Map(),
+    boundSpyMethods: /* @__PURE__ */ new Map(),
+    store: createProxyPropStore(overrides)
+  };
+  const { store } = state;
   const handler = {
-    get(target, key, receiver) {
-      const patched = readStoredAccessor(store, key, receiver);
-      if (patched !== NOT_STORED) {
-        return patched;
-      }
-      if (store.values.has(key)) {
-        return store.values.get(key);
-      }
-      if (key === "then" || isProtocolKey(key)) {
-        return void 0;
-      }
-      if (getSpySurfaceKeys().has(key)) {
-        return readSpyMember(target, key, receiver, boundSpyMethods);
-      }
-      if (typeof key === "symbol" || isDeletedProp(store, key)) {
-        return void 0;
-      }
-      if (!children.has(key)) {
-        children.set(key, createDeepNode(`${name}.${String(key)}`, {}, selfReturning));
-      }
-      return children.get(key);
-    },
+    get: (target, key, receiver) => readNodeMember(state, target, key, receiver),
     set(_target, key, value, receiver) {
       if (!writeStoredAccessor(store, key, value, receiver)) {
         writeStoredValue(store, key, value);
@@ -105,7 +114,7 @@ function collectAccessorMocks(spy) {
   }
   return [...Object.values(bag.getters), ...Object.values(bag.setters)].filter(isMarkedMock);
 }
-function collectMocks(spy) {
+function collectOwnMocks(spy) {
   const mocks = [];
   Object.keys(spy).forEach((key) => {
     const descriptor = Object.getOwnPropertyDescriptor(spy, key);
@@ -118,6 +127,24 @@ function collectMocks(spy) {
   });
   return [...mocks, ...collectAccessorMocks(spy)];
 }
+function collectMocks(spy) {
+  const mocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    if (isMarkedMock(value)) {
+      mocks.push(value);
+      readDeepChildren(value).forEach(visit);
+      return;
+    }
+    collectOwnMocks(value).forEach(visit);
+  };
+  visit(spy);
+  return mocks;
+}
 function clearAutoSpy(spy) {
   const adapter = getMockAdapter();
   collectMocks(spy).forEach((mock) => {

package/dist/{chunk-F3NMY5KU.js → chunk-TMO2UFLD.js}

@@ -1,8 +1,8 @@
-import { createSpyFromClass, createAutoMock } from './chunk-RJJJTLQ3.js';
-import { isAutoSpyLike } from './chunk-OEQTH7RA.js';
+import { createSpyFromClass, createAutoMock } from './chunk-DNHLQG45.js';
+import { isAutoSpyLike } from './chunk-WT75WGQZ.js';
 import { withDocs, DOCS_LINKS } from './chunk-VR5GJRBS.js';
 import { TestBed } from '@angular/core/testing';
-import { NO_ERRORS_SCHEMA, Injector, runInInjectionContext, ApplicationRef, ɵSIGNAL as _SIGNAL } from '@angular/core';
+import { Injector, runInInjectionContext, NO_ERRORS_SCHEMA, ApplicationRef, ɵSIGNAL as _SIGNAL } from '@angular/core';
 
 function provideAutoSpy(ObjectClass, methodsToSpyOnOrConfig) {
   return {
@@ -32,42 +32,6 @@ function warnWhenNotASpy(token, injected) {
     )
   );
 }
-function isStandalone(component) {
-  const definition = Reflect.get(component, "\u0275cmp");
-  return typeof definition === "object" && definition !== null && Reflect.get(definition, "standalone") === true;
-}
-function buildOverride(component, options) {
-  const override = {};
-  if (isStandalone(component)) {
-    override.imports = options.keepChildren ?? [];
-    override.schemas = [NO_ERRORS_SCHEMA];
-  }
-  if (!options.keepTemplate) {
-    override.template = options.template ?? "";
-    override.styles = [];
-  }
-  return override;
-}
-function applyInputs(fixture, inputs) {
-  Object.entries(inputs ?? {}).forEach(([name, value]) => fixture.componentRef.setInput(name, value));
-}
-function renderShallow(component, options = {}) {
-  const standalone = isStandalone(component);
-  TestBed.configureTestingModule({
-    imports: standalone ? [component, ...options.imports ?? []] : options.imports ?? [],
-    declarations: standalone ? [] : [component],
-    providers: options.providers ?? [],
-    schemas: [NO_ERRORS_SCHEMA]
-  });
-  TestBed.overrideComponent(component, { set: buildOverride(component, options) });
-  options.beforeCreate?.();
-  const fixture = TestBed.createComponent(component);
-  applyInputs(fixture, options.inputs);
-  if (options.detectChanges ?? true) {
-    fixture.detectChanges();
-  }
-  return { fixture, component: fixture.componentInstance };
-}
 function createSpyForToken(token) {
   if (typeof token === "function") {
     return createSpyFromClass(token, { lazySpies: true });
@@ -109,17 +73,41 @@ function createWithAutoSpies(target, options = {}) {
     }
   };
 }
-function flushEffects() {
-  const testBed = TestBed;
-  if (typeof testBed.tick === "function") {
-    testBed.tick();
-    return;
+function isStandalone(component) {
+  const definition = Reflect.get(component, "\u0275cmp");
+  return typeof definition === "object" && definition !== null && Reflect.get(definition, "standalone") === true;
+}
+function buildOverride(component, options) {
+  const override = {};
+  if (isStandalone(component)) {
+    override.imports = options.keepChildren ?? [];
+    override.schemas = [NO_ERRORS_SCHEMA];
   }
-  TestBed.inject(ApplicationRef).tick();
+  if (!options.keepTemplate) {
+    override.template = options.template ?? "";
+    override.styles = [];
+  }
+  return override;
 }
-async function stable(fixture) {
-  flushEffects();
-  await fixture.whenStable();
+function applyInputs(fixture, inputs) {
+  Object.entries(inputs ?? {}).forEach(([name, value]) => fixture.componentRef.setInput(name, value));
+}
+function renderShallow(component, options = {}) {
+  const standalone = isStandalone(component);
+  TestBed.configureTestingModule({
+    imports: standalone ? [component, ...options.imports ?? []] : options.imports ?? [],
+    declarations: standalone ? [] : [component],
+    providers: options.providers ?? [],
+    schemas: [NO_ERRORS_SCHEMA]
+  });
+  TestBed.overrideComponent(component, { set: buildOverride(component, options) });
+  options.beforeCreate?.();
+  const fixture = TestBed.createComponent(component);
+  applyInputs(fixture, options.inputs);
+  if (options.detectChanges ?? true) {
+    fixture.detectChanges();
+  }
+  return { fixture, component: fixture.componentInstance };
 }
 function readReactiveNode(candidate) {
   if (typeof candidate !== "object" || candidate === null) {
@@ -150,5 +138,63 @@ function runEffect(effectRef) {
   }
   node.fn();
 }
+var setTimer = globalThis.setTimeout.bind(globalThis);
+var clearTimer = globalThis.clearTimeout.bind(globalThis);
+function flushEffects() {
+  const testBed = TestBed;
+  if (typeof testBed.tick === "function") {
+    testBed.tick();
+    return;
+  }
+  TestBed.inject(ApplicationRef).tick();
+}
+async function stable(fixture, options = {}) {
+  flushEffects();
+  const timeout = options.timeout ?? 2e3;
+  if (timeout <= 0) {
+    await fixture.whenStable();
+    return;
+  }
+  let watchdog = void 0;
+  try {
+    await Promise.race([
+      fixture.whenStable(),
+      new Promise((_resolve, reject) => {
+        watchdog = setTimer(() => reject(unstableError(timeout, options.label)), timeout);
+      })
+    ]);
+  } finally {
+    clearTimer(watchdog);
+  }
+}
+function unstableError(timeout, label) {
+  const what = label ?? "the fixture";
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] stable: ${what} was still unstable after ${timeout} ms. A pending HttpClient request keeps a fixture unstable, and under \`provideHttpClientTesting\` only the spec can complete one \u2014 flush it before awaiting (\`TestBed.inject(HttpTestingController).expectOne(url).flush(body)\`), or use \`settleResource()\` if what you are waiting for is a resource. The other cause is a real timer: a \`setInterval\` or a long \`setTimeout\` the component started keeps Angular busy for as long as it runs, and \`setupFakeTimers()\` plus \`advanceTimers()\` is how a spec gets past that. Raise \`{ timeout }\` only once neither is true.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
+
+// src/lib/settle-resource.ts
+var PENDING_STATUSES = /* @__PURE__ */ new Set(["loading", "reloading"]);
+async function settleResource(target, options = {}) {
+  const turns = options.turns ?? 20;
+  for (let turn = 0; turn <= turns; turn += 1) {
+    if (!PENDING_STATUSES.has(target.status())) {
+      return;
+    }
+    flushEffects();
+    await Promise.resolve();
+  }
+  const what = options.label ?? "the resource";
+  throw new Error(
+    withDocs(
+      `[vitest-auto-spy] settleResource: ${what} was still '${target.status()}' after ${turns} rounds of tick + microtask. A resource stays loading until its request completes, and under \`provideHttpClientTesting\` nothing but the spec can complete one \u2014 flush it first (\`TestBed.inject(HttpTestingController).expectOne(url).flush(body)\`), then await this again. If there is no request to flush, the resource never started: its \`request()\` computation reads a signal the test never set, or the injection context it was created in was discarded. And if the loader resolves on a *timer* rather than a promise, no number of turns will do it \u2014 \`advanceTimers()\` is what moves those.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
 
-export { createWithAutoSpies, flushEffects, injectSpy, provideAutoSpy, provideAutoSpyForToken, renderShallow, runEffect, stable };
+export { createWithAutoSpies, flushEffects, injectSpy, provideAutoSpy, provideAutoSpyForToken, renderShallow, runEffect, settleResource, stable };