vitest-auto-spy 3.10.0 → 3.12.0

package/AGENTS.md

@@ -77,7 +77,8 @@ Do you have a real class at runtime?
          ├── yes, and reads chain (a.b.c())         → mockDeep<T>(overrides?)        → DeepMockProxy<T>
          ├── yes, and CALLS chain (a.b().c())       → mockDeep<T>({}, { selfReturning: true })
          └── no, it is only READ (DTO, config, route snapshot)
-                                                    → createMock<T>(partial?)        → T   (no spies)
+                 ├── one spec, a couple of fields   → createMock<T>(partial?)        → T   (no spies)
+                 └── many specs, one shared model   → createFixtureFactory<T>(defaults) → (overrides?) => T
 
 One standalone function?          → createFunctionSpy<Fn>('name')
 Code under test does `new Foo()`? → a real class?  createSpyClass(Foo)
@@ -97,6 +98,16 @@ noise scales with the number of them.
 `createMock<T>()` is the one to reach for on data shapes — it returns a plain `T`, so it satisfies a
 `no-type-assertion` lint rule without an `eslint-disable` on every fixture.
 
+**`createFixture<T>(defaults, overrides?)` / `createFixtureFactory<T>(defaults)` are for the model
+that more than one spec builds.** The difference from `createMock` is the `defaults` argument: it is
+a **complete** `T`, checked in full, in one place — so a field the model dropped fails there instead
+of in eight copies of a hundred-line literal. Overrides are deep-partial-checked and merge leaf by
+leaf; an overridden array replaces the default one. Every call hands back a fresh object and the
+defaults are copied at build time, which is what keeps one test's mutation out of the next test —
+across files, under `isolate: false`. The copy is deep through plain objects and arrays only: a
+`Date`, a `Map` or a class instance travels by reference, because rebuilding it would strip its
+prototype. Defaults that are a class instance with getters go through `withOverrides()` first.
+
 **`mockDeep` builds depth on property access, not on calls** — the distinction the tree now spells
 out, and the one that costs an afternoon otherwise. `mock.repo.user.find()` chains because every hop
 but the last is a _read_. A node that is **called** returns what it was configured to return, and by
@@ -1539,6 +1550,37 @@ assertNgModuleScopes(DirectivesModule, PipesModule); // throws, naming the modul
 Then declare what the spec needs in the TestBed module directly. Pass only modules you expect to
 bring declarations — a providers-only module is legitimately empty.
 
+### A component whose own definition has a hole in it
+
+The same bundle, one level down. A component's `providers`, `viewProviders` and compiled scope are
+**baked into `ɵcmp` when its module executes**, not read at `createComponent` time — so a barrel
+split into a chunk that has not run yet produces a definition with `undefined` in those lists.
+Angular finds out much later, from inside itself, with a stack that names neither the barrel nor the
+component:
+
+```
+TypeError: Cannot read properties of undefined (reading 'provide')
+  ❯ resolveProvider render3/di_setup.ts:95
+```
+
+Both obvious cures fail: `await import('@scope/lib')` at the top of `beforeEach` is already too late,
+and a static import at the top of the spec does not fix the order this bundler emits. Worse, the spec
+that breaks is one nobody touched — chunk boundaries move with file *contents*, so editing a type
+next door is enough.
+
+```ts
+import { assertComponentDefIntact } from 'vitest-auto-spy/angular';
+
+assertComponentDefIntact(HoverMenuComponent); // HoverMenuComponent.ɵcmp.providers[0] is undefined
+const fixture = TestBed.createComponent(HoverMenuComponent);
+```
+
+It walks the three lists, nested arrays and forward-reference thunks included, and answers the
+related `Cannot read properties of undefined (reading 'ɵcmp')` from `imports: [Cmp]` as well — there
+the class reference itself never arrived, and the message names the argument position. Directives
+(`ɵdir`) are checked the same way. Neither this nor `assertNgModuleScopes` fixes the build; both
+replace a stack inside `@angular/core` with a line naming what is missing.
+
 ### Four silent failures, as one setup line
 
 ```ts
@@ -1886,8 +1928,9 @@ export default [{ files: ['**/*.spec.ts'], ...autoSpy.configs.recommended }];
 | `no-overridden-provider`       | `error` | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                 |
 | `no-inject-before-override`    | `warn`  | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                     |
 | `no-import-time-spread`        | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                   |
+| `no-unregistered-inject-spy`   | `warn`  | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler |
 
-Thirteen rules; two fix on their own, six offer suggestions. `no-mocked-for-spy` only ever touches a
+Fourteen rules; two fix on their own, six offer suggestions. `no-mocked-for-spy` only ever touches a
 **type position**, where a wrong rewrite is a compile error rather than a test that quietly changed
 meaning — so `--fix` renames the type, adds `import type { Spy } from 'vitest-auto-spy'` and drops
 the orphaned `Mocked` import. Every type position, not only a `let`: a factory's return type, a
@@ -2014,6 +2057,9 @@ packages, which a subpath export can never be.
 | `overrideComponentProvider(…): the override did not apply`                           | the component injects a different token, or a later `overrideProvider` won                                                                           | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures |
 | `the test ended with N unflushed HttpTestingController request(s)`                   | `enableAngularDiagnostics({ pendingRequests })` — nothing answered them                                                                              | flush each (`controller.expectOne(url).flush(body)`), or `controller.verify()` where absence is the assertion (§13)              |
 | `NgModule(s) with an empty runtime scope: …`                                         | `ngModuleScopes` (or `assertNgModuleScopes`) — an AOT test bundle stripped `ɵɵsetNgModuleScope`, so the import contributes nothing                   | declare what the spec needs in the TestBed module directly; pass only modules expected to bring declarations (§13)               |
+| `Cannot read properties of undefined (reading 'provide')`, stack inside `render3/di_setup`         | a barrel chunk had not run when the component's definition was built, so a provider slot is `undefined`                                              | `assertComponentDefIntact(Cmp)` before `createComponent` — it names the list and the index (§13)                                 |
+| `assertComponentDefIntact(): argument N is undefined, which carries no ɵcmp or ɵdir`               | the class reference itself never arrived — the `Cannot read properties of undefined (reading 'ɵcmp')` case                                           | the same split barrel; import the component from its own module, not the barrel (§13)                                            |
+| `TS1117: An object literal cannot have multiple properties with the same name`, in a fixture       | a hundred-line model literal copied into eight specs and edited independently                                                                        | one `createFixtureFactory<T>(defaults)`; note the runtime keeps the **second** key, so do not auto-fix by dropping one (§12)      |
 | `configureTestingModule was given N schema(s) that can never apply`                  | `enableAngularDiagnostics({ deadSchemas })` — `schemas` next to a standalone component, with `declarations` empty                                    | drop the `schemas` entry and put the missing directive/pipe in the component's own `imports`, or use `createDirectiveHost` (§13) |
 | `injectSpy(X): the injector returned a plain instance, not an auto-spy`              | the token is provided for real; a `console.warn` on its own, a **throw** under `enableAngularDiagnostics({ unspiedProviders })`                      | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants           |
 | `trackInjections(...).get(X): that token is not tracked by this log`                 | `get` only answers for tokens whose providers the log created                                                                                        | add the token to the `trackInjections([...])` list, or read it from the injector directly (§13)                                  |

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-14.3%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-14.5%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)
@@ -49,7 +49,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 - ⚙️ 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`, `settleResource` for `httpResource()`, `toHaveSignalValue`, per-file `TestBed` timings
-- 🧱 The providers a testing module cannot reach — `overrideComponentProvider` (which verifies the override actually applied), `provideAutoSpyForToken`, `assertNgModuleScopes`, `createDirectiveHost`
+- 🧱 The providers a testing module cannot reach — `overrideComponentProvider` (which verifies the override actually applied), `provideAutoSpyForToken`, `assertNgModuleScopes`, `assertComponentDefIntact`, `createDirectiveHost`
 - 🚨 Failures that used to be silence — `enableAngularDiagnostics()` for dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests; `trackInjections` for which collaborators the code actually asked for
 - 🔒 [Strict doubles](#strict-doubles--fail-on-a-method-nobody-configured) — `strict: true` / `onUnstubbedCall` fail on a method nobody configured, naming the class, the method and the arguments instead of answering `undefined`
 - ♻️ `using spy = createSpyFromClass(X)` — every double carries `[Symbol.dispose]`, so the `afterEach` that only reset one spy can go
@@ -58,7 +58,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 - ⏳ Waiting that is not a guess — `flushEventLoop`, `settleDynamicImport`, `flushEventLoopUntil`, and a clock that survives fake timers (`mockSystemTime`, `useCountingClock`)
 - 🌀 `fakeAsync` / `waitForAsync` on Vitest — one import of `vitest-auto-spy/zone`; zone.js stays out of every other entry
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored
-- 🧾 Fixtures without casts — deep-partial `createMock`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
+- 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
 - 🚚 A migration you can verify — `compareTestRuns` on the two JSON reports, `diffByField` for the assertion the reporter collapses
 - 📏 Lint rules and one-line test-run hygiene — fourteen rules in `vitest-auto-spy/eslint-plugin` (two `--fix`, six suggestions), `setupAutoSpy()`
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
@@ -1171,6 +1171,40 @@ Rule of thumb: `createAutoMock` for a collaborator you **call** and assert on, `
 data shape you **read**. `createMock` is also the one place the `as` lives, so a suite under a
 `no-type-assertion` lint rule stops sprinkling `eslint-disable` over its fixtures.
 
+### A model many specs build — `createFixture` / `createFixtureFactory`
+
+`createMock` answers "this spec reads two fields of a big shape". The other habit is more expensive:
+a model with seventeen required fields, each with its own nested interface, copied into every spec
+that needs one. Measured on one migration shard, those copies alone produced **28 `TS1117`**
+diagnostics — a duplicate key in a literal, where the runtime keeps the *second* one.
+
+```ts
+import { createFixtureFactory } from 'vitest-auto-spy';
+
+// article.fixture.ts — the model, written out once and checked in full
+export const anArticle = createFixtureFactory<Article>({
+  id: '1',
+  header: { title: '', subtitle: 'none' },
+  tags: [],
+  publishedAt: new Date(0),
+});
+
+// in a spec — name only what this test is about
+const draft = anArticle({ header: { title: 'Draft' } });  // header.subtitle survives
+```
+
+`defaults` is a **complete** `T`, and that is the point rather than a chore: a field the model
+dropped six months ago fails in one place instead of in eight copies nobody re-checks. `Partial<T>`
+and `as T` both delete that diagnostic. Overrides are deep-partial-checked and merge leaf by leaf; an
+overridden array replaces the default one outright.
+
+Every call returns a **new object**, and the defaults are copied when the factory is built — a
+fixture shared by reference is the most common way one test's mutation decides another's outcome, and
+under `isolate: false` that reaches across files. The copy is deep through plain objects and arrays
+and stops there: a `Date`, a `Map` or a class instance is carried across by reference rather than
+rebuilt without its prototype. For defaults that *are* a class instance with getters, snapshot them
+with `withOverrides()` first.
+
 ## Synchronous methods
 
 ```ts
@@ -1813,6 +1847,8 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `createFunctionSpy(name)`                                                            | core                          | A single standalone function spy with the full helper set (`calledWith`, `resolveWith`, `nextWith`, …) — no class needed                                      |
 | `createAutoMock<T>(overrides?)`                                                      | core                          | Proxy-based spy from a **type/interface** alone ([details](#auto-mock-by-type-no-class-needed))                                                               |
 | `createMock<T>(partial?)`                                                            | core                          | A plain, spy-free `T` built from the fields a test seeds — for data shapes, not collaborators                                                                 |
+| `createFixture<T>(defaults, overrides?)`                                             | core                          | One `T` from a complete, checked default plus what this test changes — a fresh copy every call                                                                |
+| `createFixtureFactory<T>(defaults)`                                                  | core                          | Somewhere to put that default: returns `(overrides?) => T`, with the defaults pinned at build time                                                            |
 | `createObservableWithValues(configs, opts?)`                                         | `/rxjs`                       | Build a fake `Observable` emitting a precise sequence of values / errors / completion                                                                         |
 | `consoleInfoSpy` / `consoleWarnSpy` / …                                              | `/console`                    | Silent typed spies over the global `console`, installed on import ([details](#console-spies--vitest-auto-spyconsole))                                         |
 | `mockReadonlyProp(obj, prop, value)`                                                 | `/angular`                    | Overwrite a `readonly` property (incl. Angular signals) with a static value                                                                                   |
@@ -1850,6 +1886,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `registerFocusMatchers()`                                                            | `/setup`                      | Adds `expect(el).toHaveFocus()`, which names _why_ focus is elsewhere                                                                                         |
 | `overrideAutoSpy(Token, config?)` / `overrideComponentProvider(Cmp, Token, config?)` | `/angular`                    | Replace a dependency a component declares in its own `providers`                                                                                              |
 | `assertNgModuleScopes(...modules)`                                                   | `/angular`                    | Fail early when an AOT test bundle left an NgModule with no runtime declarations                                                                              |
+| `assertComponentDefIntact(...components)`                                            | `/angular`                    | Fail before rendering when a half-loaded barrel chunk left a hole in a component's own `providers` or scope                                                   |
 | `enableAngularDiagnostics(opts?)` / `assertNoPendingRequests()`                      | `/angular`                    | Dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests, as failures ([details](#diagnostics--four-silent-failures-made-loud)) |
 | `trackInjections(tokens, opts?)`                                                     | `/angular`, `/nestjs`         | Which collaborators DI actually constructed, recorded through provider factories — with the doubles attached                                                  |
 | `mockSignalProp(obj, prop, initial)`                                                 | `/angular`                    | Replace a signal-valued property with a real `WritableSignal`, and hand the writable handle back                                                              |
@@ -2271,6 +2308,20 @@ seven sites in an 8 673-file workspace, which is small enough to flag at the cur
 and an instance field are deliberately not reported — they run later than the module does — while a
 `static` field is.
 
+The fourteenth, `no-unregistered-inject-spy`, catches `injectSpy(X)` for a token nothing in the file
+registered as an auto-spy. What comes back is whatever Angular DI already had — the real service, or
+an object an imported testing module put there — and nothing complains, because `injectSpy` is
+declared to return a `Spy<T>`: the helpers are present for `tsc` and absent at run time, so the first
+`.mockReturnValue(…)` or `.calledWith(…)` throws on a real method. The library warns about exactly
+this at run time, and that warning is why the rule exists rather than why it is redundant — it does
+not fail the run, it scrolls past in a suite of a thousand files, and it arrives only for the tests
+that executed the line; in one consumer monorepo dozens of spec files print it on every CI run and it
+has never been acted on. Reading it at the cursor needs no types, only the file's own registrations,
+and the rule stays quiet unless it can read all of them: it needs at least one `provideAutoSpy`, and
+a spread, an unknown provider factory, `createWithAutoSpies`, `renderShallow` or
+`TestBed.overrideProvider` silences the file. A token handed a plain `useValue` is left to
+`prefer-provide-auto-spy` — two rules on one line only teach people to disable both.
+
 ## Editor diagnostics — WebStorm & VS Code
 
 The rules above are worth more while the cursor is still on the line than they are in CI, because
@@ -2280,7 +2331,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the twelve rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the fourteen rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -2297,7 +2348,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of twelve rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of fourteen rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -2328,6 +2379,31 @@ asSpy(TestBed.inject(CartService)); // CartService → Spy<CartService>, for the
 
 Both are the same object at runtime; only the view changes.
 
+### Error → cure
+
+Keyed by what the compiler prints, because that is what you have when you get there. The helper
+names are unfindable from these messages otherwise — no `TS2739` text contains the word `asInstance`.
+
+| Message                                                                         | What actually happened                    | Cure                                              |
+| ------------------------------------------------------------------------------- | ----------------------------------------- | -------------------------------------------------- |
+| `TS2352 … 'Spy<X>' … Property 'accessorSpies' is missing in type 'X'`           | `x as Spy<X>`, written by hand            | `asSpy(x)` — never a double assertion              |
+| `TS2739` / `TS2740`: `'Spy<X>' is missing … ` + a list of **private** fields     | a spy handed to an API typed against `X`  | `asInstance(spy)`                                   |
+| `TS2345: Argument of type 'Spy<X>' is not assignable to parameter of type 'X'`   | the same, in an argument                  | `asInstance(spy)`, or `asInstances(a, b, c)`        |
+| `TS2322: Type 'Spy<X>' is not assignable to type 'Mocked<X>' …`                  | the variable was declared `Mocked<T>`     | declare it `Spy<T>`                                 |
+| `'AddPromiseSpyMethods<unknown>' is missing … from type 'WithMockReturnValue<…>'` | a generic class inferred as `Service<any>` | `asSpy<Service>(…)` / `injectSpy<Service>(…)`      |
+| `TS2739 … 'Spy<X>' is missing …` **on a line with `injectSpy`**                  | the provider handed back the real object  | `provideAutoSpy(X)`, or an honest `TestBed.inject`  |
+
+Two notes that cost real time when they are missing.
+
+**The last row is word for word the second one**, and that is a property of the language rather than
+a flaw in the table: one message serves two different mistakes. The tell is the line it lands on.
+
+**The error count does not go down monotonically.** TypeScript stops checking a call at the first bad
+argument, so "one error left" means "as many as there are unfixed arguments" — one file counted
+40 → 1 → 1 → 1 → 0. Excess-property checking stops at the first unknown key of a literal for the same
+reason. The useful heuristic: if a file already contains one `asInstance`, it almost certainly needs
+another, and the next one is in that same file.
+
 ## API reference
 
 | Export                                                                                                       | Description                                                                                                                                         |
@@ -2335,6 +2411,7 @@ Both are the same object at runtime; only the view changes.
 | `createSpyFromClass(Class, methodsOrConfig?)`                                                                | Build a fully-typed `Spy<T>` from a class                                                                                                           |
 | `createAutoMock<T>(overrides?, config?)`                                                                     | Build a `Spy<T>` from a **type/interface** alone (Proxy, no class); `{ returns, observablePropsToSpyOn }` configure it                              |
 | `createMock<T>(partial?)`                                                                                    | Build a plain, spy-free `T` from the fields a test seeds — for data shapes the code under test reads                                                |
+| `createFixture<T>(defaults, overrides?)` / `createFixtureFactory<T>(defaults)`                                | A model written out and checked once, stamped into a fresh copy per test — for the fixture eight specs would otherwise each keep a copy of          |
 | `mockDeep<T>(overrides?, options?)`                                                                          | Build a **recursive** auto-mock — `mock.repo.user.find()` chains without seeding; `{ selfReturning: true }` chains through calls too                |
 | `resetAutoSpy(spy)` / `clearAutoSpy(spy)`                                                                    | Reset every spy in an auto-spy at once — `reset` also reverts return-value config (`calledWith` **and** a bare `mockReturnValue`); `clear` keeps it |
 | `spy[Symbol.dispose]()`                                                                                      | What `using spy = createSpyFromClass(X)` runs at the end of the block — `resetAutoSpy(this)`, on every double including each `mockDeep` node        |
@@ -2357,7 +2434,7 @@ Both are the same object at runtime; only the view changes.
 | `autoMocked<T>(overrides?)`                                                                                  | `createAutoMock` typed as `T & Spy<T>`                                                                                                              |
 | `mockSystemTime` / `withSystemTime` / `mockNow` / `useCountingClock` _(`/setup`)_                            | Clock control that survives fake timers being re-installed per test                                                                                 |
 | `registerFocusMatchers()` _(`/setup`)_                                                                       | Adds `expect(el).toHaveFocus()`                                                                                                                     |
-| `overrideAutoSpy` / `overrideComponentProvider` / `assertNgModuleScopes` _(Angular)_                         | Override a component-level provider — and verify on the next fixture that the override applied; diagnose an NgModule with an empty runtime scope    |
+| `overrideAutoSpy` / `overrideComponentProvider` / `assertNgModuleScopes` / `assertComponentDefIntact` _(Angular)_                         | Override a component-level provider — and verify on the next fixture that the override applied; diagnose an NgModule with an empty runtime scope    |
 | `enableAngularDiagnostics(opts?)` / `disableAngularDiagnostics()` / `assertNoPendingRequests()` _(Angular)_  | Dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests, as failures                                                 |
 | `trackInjections(tokens, opts?)` _(Angular, NestJS)_                                                         | Providers that record which collaborators DI constructed, with an auto-spy behind each token                                                        |
 | `setupAutoSpy(opts?)` _(`/setup`)_                                                                           | Property restore + duplicate-copy detection + mock-registry hygiene, in one call                                                                    |

package/dist/angular.d.ts

@@ -35,6 +35,12 @@ import 'vitest';
  * landed. So {@link overrideComponentProvider} also checks, on the next `TestBed.createComponent`,
  * that the component's own injector really answers with the spy — see {@link verifyOnNextCreate}
  * for why that check is always on rather than an opt-in diagnostic.
+ *
+ * The same AOT bundle is behind the two assertions at the end of the file.
+ * {@link assertNgModuleScopes} covers the module whose scope the bundler stripped;
+ * {@link assertComponentDefIntact} covers the component whose own definition was built while the
+ * chunk holding one of its providers had not run yet. Neither fixes a build — both replace a stack
+ * inside `@angular/core` with a line naming the thing that is missing.
  */
 
 /** The `{ useValue }` shape `TestBed.overrideProvider` expects, carrying an auto-spy. */
@@ -75,6 +81,39 @@ declare function overrideAutoSpy<T>(ObjectClass: ClassType<T>, methodsToSpyOnOrC
  * runtime scope the bundler has stripped — leaving the component with none of them.
  */
 declare function overrideComponentProvider<T>(component: Type<unknown>, ObjectClass: ClassType<T>, methodsToSpyOnOrConfig?: ClassSpyConfiguration<T> | OnlyMethodKeysOf<T>[]): Spy<T>;
+/**
+ * Fail before rendering when a component's own definition has holes in it.
+ *
+ * Providers are **baked into `ɵcmp` when the component's module executes**, not read at
+ * `createComponent` time. So when a bundler splits a barrel into a chunk that has not run yet, the
+ * definition is built with `undefined` where a provider or a scope dependency should be, and Angular
+ * discovers it much later, from inside itself:
+ *
+ * ```
+ * TypeError: Cannot read properties of undefined (reading 'provide')
+ *   ❯ resolveProvider render3/di_setup.ts:95
+ * ```
+ *
+ * The stack names neither the barrel, nor the symbol, nor the component — and the spec it breaks is
+ * usually one nobody touched, because chunk boundaries move with file *contents*: editing a type in
+ * a neighbouring file is enough. Both documented cures fail, too, and for the same reason: an
+ * `await import()` in `beforeEach` is already too late, and a static import at the top of the spec
+ * does not fix the order this bundler emits.
+ *
+ * ```ts
+ * assertComponentDefIntact(HoverMenuComponent);
+ * const fixture = TestBed.createComponent(HoverMenuComponent);
+ * ```
+ *
+ * The same call answers the related `Cannot read properties of undefined (reading 'ɵcmp')` from
+ * `imports: [Cmp]`, where the class reference itself is the thing that never arrived.
+ *
+ * This does not fix the build — that is a bundler configuration question — but it turns a
+ * half-hour investigation into one line, and points it away from the spec.
+ *
+ * @param components The component (or directive) classes a spec is about to render or import.
+ */
+declare function assertComponentDefIntact(...components: unknown[]): void;
 /**
  * Fail early when an NgModule imported into the TestBed contributes nothing at runtime.
  *
@@ -576,4 +615,4 @@ declare function reportSpecTiming(timing: SpecTiming): void;
  */
 declare function enableTestBedDiagnostics(options?: TestBedDiagnosticsOptions): void;
 
-export { type AngularDiagnosticsOptions, type AngularTestEnvMode, type AngularTestEnvOptions, type AutoSpyOverride, type DirectiveHostOptions, type MockedResource, type ResourceDouble, type ResourceDoubleStatus, type ResourceLike, type SignalLike, type SpecTiming, type TestBedDiagnosticsOptions, assertNgModuleScopes, assertNoPendingRequests, createDirectiveHost, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, mockResourceProp, mockSignalProp, overrideAutoSpy, overrideComponentProvider, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, reportSpecTiming, setupAngularTestEnv };
+export { type AngularDiagnosticsOptions, type AngularTestEnvMode, type AngularTestEnvOptions, type AutoSpyOverride, type DirectiveHostOptions, type MockedResource, type ResourceDouble, type ResourceDoubleStatus, type ResourceLike, type SignalLike, type SpecTiming, type TestBedDiagnosticsOptions, assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, createDirectiveHost, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, mockResourceProp, mockSignalProp, overrideAutoSpy, overrideComponentProvider, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, reportSpecTiming, setupAngularTestEnv };

package/dist/angular.js

@@ -1402,6 +1402,66 @@ function moduleName(module) {
   const name = readProperty(module, "name");
   return typeof name === "string" ? name : String(module);
 }
+var DEFINITION_LISTS = ["providers", "viewProviders", "dependencies"];
+function resolveList(list) {
+  if (typeof list !== "function") {
+    return list;
+  }
+  try {
+    const produced = Reflect.apply(list, void 0, []);
+    return produced;
+  } catch {
+    return void 0;
+  }
+}
+function collectHoles(list, path, holes) {
+  const resolved = resolveList(list);
+  if (!Array.isArray(resolved)) {
+    return;
+  }
+  resolved.forEach((entry, index) => {
+    const at = `${path}[${index}]`;
+    if (entry === void 0 || entry === null) {
+      holes.push(at);
+    } else if (Array.isArray(entry)) {
+      collectHoles(entry, at, holes);
+    }
+  });
+}
+function definitionOf(type) {
+  const component = readProperty(type, "\u0275cmp");
+  if (component !== void 0) {
+    return { definition: component, key: "\u0275cmp" };
+  }
+  const directive = readProperty(type, "\u0275dir");
+  return directive === void 0 ? void 0 : { definition: directive, key: "\u0275dir" };
+}
+function assertComponentDefIntact(...components) {
+  components.forEach((component, position) => {
+    const named = moduleName(component);
+    const found = definitionOf(component);
+    if (!found) {
+      throw new Error(
+        withDocs(
+          `[vitest-auto-spy] assertComponentDefIntact(): argument ${position} is ${named}, which carries no \u0275cmp or \u0275dir.
+Either it is not a component or directive, or the chunk that defines it has not executed yet \u2014 the import resolved to nothing. A barrel split across chunks is the usual cause.`,
+          DOCS_LINKS.angularOverrides
+        )
+      );
+    }
+    const holes = [];
+    DEFINITION_LISTS.forEach((list) => collectHoles(readProperty(found.definition, list), `${named}.${found.key}.${list}`, holes));
+    if (holes.length > 0) {
+      throw new Error(
+        withDocs(
+          `[vitest-auto-spy] ${holes.join(", ")} ${holes.length === 1 ? "is" : "are"} undefined.
+A component bakes its providers and its scope into the definition when its module executes, so a hole there means the chunk holding that symbol had not run at that moment \u2014 an uninitialised barrel chunk. Angular reports this much later as "Cannot read properties of undefined (reading 'provide')", from inside its own provider resolution.`,
+          DOCS_LINKS.angularOverrides
+        )
+      );
+    }
+  });
+}
 function assertNgModuleScopes(...modules) {
   const empty = modules.filter(hasEmptyRuntimeScope).map(moduleName);
   if (empty.length === 0) {
@@ -2009,4 +2069,4 @@ function registerSignalMatchers() {
 }
 useVitestAdapter();
 
-export { assertNgModuleScopes, assertNoPendingRequests, countMockedProps, createDirectiveHost, createWithAutoSpies, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, flushEffects, formatSpecTiming, getTestBedTiming, injectSpy, instrumentTestBed, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockResourceProp, mockSignalProp, mockValueProp, overrideAutoSpy, overrideComponentProvider, provideAutoSpy, provideAutoSpyForToken, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, renderShallow, reportSpecTiming, restoreMockedProps, runEffect, settleResource, setupAngularTestEnv, stable, trackInjections };
+export { assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, countMockedProps, createDirectiveHost, createWithAutoSpies, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, flushEffects, formatSpecTiming, getTestBedTiming, injectSpy, instrumentTestBed, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockResourceProp, mockSignalProp, mockValueProp, overrideAutoSpy, overrideComponentProvider, provideAutoSpy, provideAutoSpyForToken, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, renderShallow, reportSpecTiming, restoreMockedProps, runEffect, settleResource, setupAngularTestEnv, stable, trackInjections };

package/dist/bun-angular.d.ts

@@ -1,5 +1,5 @@
 export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.js';
-export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
+export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
 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-CuGjE0YR.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-IgCwv_40.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';

package/dist/bun-angular.js

@@ -1,7 +1,7 @@
 import './chunk-Y4YG7UOK.js';
 import { createSpyForToken } from './chunk-LVLSMH6T.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-2U3J65A4.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
 import { createSpyFromClass } from './chunk-B7PDIHEG.js';
 export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';

package/dist/bun.d.ts

@@ -76,6 +76,88 @@ declare function createSpyFromClass<T, Options extends SpyOptions = SpyOptions>(
  */
 declare function createMock<T>(partial?: DeepPartial<T>): T;
 
+/**
+ * `createFixture` / `createFixtureFactory` — one checked copy of a data model, handed out fresh.
+ *
+ * Specs do not only spy; they *build data*, and that is where a suite meets the type checker for
+ * the first time. A content model with seventeen required fields, each with its own nested
+ * interface, gets copied into every spec that needs it: eight files, a hundred-line literal apiece.
+ * The copies then rot independently. Measured on one migration shard, that single habit produced
+ * **28 `TS1117`** diagnostics (a duplicate key in a literal — the runtime keeps the *second*, so an
+ * automated "drop one" fix silently changes values) and half of the shard's `TS2741`.
+ *
+ * The two obvious escapes are worse than the problem:
+ *
+ * - `as T` and `Partial<T>` both delete the diagnostic that made the migration worth doing —
+ *   `TS2353`, "this fixture still sets a field the model dropped six months ago". A fixture that
+ *   cannot be wrong about the model is a fixture that never reports the model changed.
+ * - {@link createAutoMock} builds an object from a type, but only its **methods**. A data model has
+ *   none, so the machine walks straight past the place the errors actually are.
+ *
+ * So the answer is not another way to skip the fields. It is somewhere to *put* them once:
+ * {@link createFixtureFactory} takes a complete, fully checked `T` — every required field, every
+ * removed field rejected, one place for the compiler to point at — and returns a function that
+ * stamps out copies with per-test changes applied. The check happens once; the fifty call sites
+ * that follow name only what they care about.
+ *
+ * **Each call returns a new object.** That is not a performance footnote — a fixture shared by
+ * reference across a file is the most common way one test's mutation decides another test's
+ * outcome, and under `isolate: false` the sharing reaches across files. The copy is deep through
+ * plain objects and arrays and stops there: a `Date`, a `Map`, a DOM node or a class instance is
+ * carried across by reference, because rebuilding one would strip its prototype — accessors
+ * included — and hand back something that is no longer the model it claims to be. When the defaults
+ * *are* a class instance with getters, snapshot it with {@link withOverrides} first and hand the
+ * result here.
+ *
+ * | | `createMock<T>()` | `createFixture<T>()` |
+ * | --- | --- | --- |
+ * | Input | the fields this test reads | a complete `T`, plus what this test changes |
+ * | Unnamed fields | `undefined` at runtime | the default's value |
+ * | Use it for | a shape read shallowly, once | a model many specs build, read deeply, and mutate |
+ */
+
+/** Stamps out one fixture per call. What {@link createFixtureFactory} returns. */
+type FixtureFactory<T> = (overrides?: DeepPartial<T>) => T;
+/**
+ * Build one `T` from a complete default and the fields this test changes.
+ *
+ * ```ts
+ * const article = createFixture<Article>(ARTICLE_DEFAULTS, { header: { title: 'Draft' } });
+ * ```
+ *
+ * `defaults` is a whole `T`, so a field the model removed is a compile error here rather than a
+ * value nothing reads; `overrides` is checked at every depth against the same type. Sibling fields
+ * of an overridden leaf are kept — `header.subtitle` above survives — while an overridden array
+ * replaces the default one entirely.
+ *
+ * Reach for {@link createFixtureFactory} as soon as a second spec needs the same defaults; reach
+ * for {@link createMock} when there are no meaningful defaults to begin with and the test reads two
+ * fields of a large shape.
+ *
+ * @param defaults A complete `T`. Checked in full: missing and removed fields both fail here.
+ * @param overrides The fields this fixture changes, checked against `T` at every depth.
+ */
+declare function createFixture<T>(defaults: T, overrides?: DeepPartial<T>): T;
+/**
+ * Somewhere to put a fixture, so that the model is written out and checked exactly once.
+ *
+ * ```ts
+ * // article.fixture.ts — one file, one checked literal
+ * export const anArticle = createFixtureFactory<Article>({ id: '1', header: { title: '', subtitle: '' }, tags: [], … });
+ *
+ * // in a spec
+ * const draft = anArticle({ header: { title: 'Draft' } });
+ * const tagged = anArticle({ tags: ['news'] });
+ * ```
+ *
+ * The defaults are copied when the factory is built, so a later edit to the object that was passed
+ * in cannot reach a fixture already handed out — and every call returns a fresh copy, so one test
+ * mutating what it was given cannot decide what the next one sees.
+ *
+ * @param defaults A complete `T`, checked once, here.
+ */
+declare function createFixtureFactory<T>(defaults: T): FixtureFactory<T>;
+
 /**
  * Behaviour switches for {@link mockDeep}.
  *
@@ -1105,4 +1187,4 @@ interface ResizeEntryRect {
  */
 declare function resizeEntry(target: Element, rect?: ResizeEntryRect): ResizeObserverEntry;
 
-export { AddSpyMethodsByReturnTypes, type ArgCaptor, type AsInstances, type AssertMockedOptions, ClassSpyConfiguration, ClassType, type ConstructorMock, type ConstructorSpy, DeepMockProxy, DeepPartial, type FlushUntilOptions, Func, type IntersectionObserverStubOptions, type MediaElementState, type MediaElementStub, type MediaElementStubOptions, type MockDeepOptions, type ModuleNamespace, type ModuleNamespaceOptions, type MutationRecordInit, type ObserverGlobal, type ObserverInstance, type ObserverStub, type ObserverStubOptions, OnlyMethodKeysOf, type ResizeEntryRect, Spy, SpyOptions, type TestRunComparison, type TestRunReport, type TestRunSummary, UnstubbedCallHandler, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides };
+export { AddSpyMethodsByReturnTypes, type ArgCaptor, type AsInstances, type AssertMockedOptions, ClassSpyConfiguration, ClassType, type ConstructorMock, type ConstructorSpy, DeepMockProxy, DeepPartial, type FixtureFactory, type FlushUntilOptions, Func, type IntersectionObserverStubOptions, type MediaElementState, type MediaElementStub, type MediaElementStubOptions, type MockDeepOptions, type ModuleNamespace, type ModuleNamespaceOptions, type MutationRecordInit, type ObserverGlobal, type ObserverInstance, type ObserverStub, type ObserverStubOptions, OnlyMethodKeysOf, type ResizeEntryRect, Spy, SpyOptions, type TestRunComparison, type TestRunReport, type TestRunSummary, UnstubbedCallHandler, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides };

package/dist/bun.js

@@ -1,6 +1,6 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-2U3J65A4.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
 export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';

package/dist/{chunk-2U3J65A4.js → chunk-FKAXOKP5.js}

@@ -9,6 +9,54 @@ function createMock(partial) {
   return partial ?? {};
 }
 
+// src/lib/fixture.ts
+var FORBIDDEN_KEY = "__proto__";
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function copyValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(copyValue);
+  }
+  return isPlainRecord(value) ? copyRecord(value) : value;
+}
+function copyRecord(record) {
+  const copy = {};
+  Object.keys(record).forEach((key) => {
+    if (key !== FORBIDDEN_KEY) {
+      copy[key] = copyValue(record[key]);
+    }
+  });
+  return copy;
+}
+function mergeValue(base, override) {
+  if (isPlainRecord(base) && isPlainRecord(override)) {
+    return mergeRecord(base, override);
+  }
+  return copyValue(override);
+}
+function mergeRecord(base, override) {
+  const merged = copyRecord(base);
+  Object.keys(override).forEach((key) => {
+    if (key !== FORBIDDEN_KEY) {
+      merged[key] = key in base ? mergeValue(base[key], override[key]) : copyValue(override[key]);
+    }
+  });
+  return merged;
+}
+function createFixture(defaults, overrides) {
+  const copy = copyValue(defaults);
+  return overrides === void 0 ? copy : mergeValue(copy, overrides);
+}
+function createFixtureFactory(defaults) {
+  const pinned = copyValue(defaults);
+  return (overrides) => createFixture(pinned, overrides);
+}
+
 // src/lib/mock-deep.ts
 function collectKeys(value) {
   const keys = /* @__PURE__ */ new Set();
@@ -753,4 +801,4 @@ function resizeEntry(target, rect = {}) {
   return entry;
 }
 
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createMock, createSpyClass, diffByField, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides };
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, diffByField, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides };