vitest-auto-spy 5.11.0 → 5.13.0

package/AGENTS.md

@@ -771,6 +771,15 @@ Precedence, first one set wins: the double's `onUnstubbedCall` → the double's
   and a `calledWith` configured after them is never consulted. After the last `mockReturnValueOnce`
   the queue empties back onto the library dispatch and the next call **is** reported as unstubbed —
   seed `mockReturnValue(...)` too when a `Once` sequence is meant to run out.
+- **That pair is reported, in both orders.** `mockReturnValue` after a `calledWith` erases it;
+  `calledWith` after a `mockReturnValue` is dead on arrival. Neither fails on its own — the spec goes
+  green on a branch nobody configured — so the library says so as a misconfiguration (warn, or throw
+  under the `strict` preset). The whole family replaces: `mockImplementation`, `mockReturnValue`,
+  `mockReturnThis`, `mockThrow`, `mockResolvedValue`, `mockRejectedValue`. When both a fallback and a
+  per-argument value are wanted, the fallback goes in the spy's container — `returns:` where the
+  double is built, or `resolveWith` / `nextWith` / `failWith` — which a `calledWith` still wins over.
+  The report is this library's own spy engine's, so Vitest and Rstest have it; Bun, `node:test` and
+  `setSpyEngine('runner')` do not. The `Once` family is never reported.
 - **A throw something swallowed still fails the test.** Under `setupAutoSpy({ strict: true })` every
   strict throw is recorded, and one that a `try`/`catch` in the code under test or an RxJS error with
   no handler (its rethrow waits on a fake clock) kept from the test fails it after the test
@@ -3418,6 +3427,7 @@ packages, which a subpath export can never be.
 | `NG0303` / `NG0304` / nothing at all, from a directive spec                                                                                         | the host is `standalone: false`, or the module is in the TestBed                                                                                                                                                                                                            | `createDirectiveHost({ template, scope: [Module] })` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `setInputs: … declares no input named …`                                                                                                            | the key is not an input of that component — a typo, an input renamed since, or one of its own fields                                                                                                                                                                        | set the names the message lists; a signal the component owns is moved through the signal (§13)                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `setInputs: X carries no ɵcmp, so there are no inputs to set`                                                                                       | the fixture's `componentType` is not a compiled `@Component` — a `@Directive` or `@Pipe` class, or one Angular never compiled (a barrel import that resolved to `undefined`)                                                                                                | pass a component fixture; a directive takes its inputs through the host element that applies it (`createDirectiveHost`), and for `undefined` import the class from its own file (§13)                                                                                                                                                                                                                                                                                                                             |
+| `TypeError: dependencies is not a function`, from `renderShallow({ keepTemplate: true })`                                                           | the compiled `ɵcmp.dependencies` is the flat array AOT emits when no cycle forced a factory, and the trim called it                                                                                                                                                         | upgrade — all three shapes (array, factory, `null`) are read; nothing to change in the spec                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `TS2540: Cannot assign to 'X' because it is a read-only property`                                                                                   | a `readonly` field of an object under test                                                                                                                                                                                                                                  | `mockValueProp(obj, 'X', value)` — on a class **getter**, `mockReadonlyProp`                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `TypeError: Cannot read properties of undefined (reading 'mockReturnValue')`                                                                        | the member is an **instance field**, not on the prototype — `Router.currentNavigation` since Angular 20                                                                                                                                                                     | `provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] })` (§5)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `throwWith` reaching the success branch first, with the previous test's value                                                                       | the spy's `ReplaySubject(1)` outlived the test that filled it                                                                                                                                                                                                               | upgrade; and `resetAutoSpy(spy)` in `beforeEach` when the TestBed is built in `beforeAll`                                                                                                                                                                                                                                                                                                                                                                                                                         |

package/README.md

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-17.2%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-17.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)
@@ -2091,6 +2091,17 @@ myService.getName.mustBeCalledWith(1).mockReturnValue('Fake Name');
 expect(() => myService.getName(2)).toThrow();
 ```
 
+**The first line and the second do not layer.** `mockReturnValue` and its family
+(`mockImplementation`, `mockResolvedValue`, `mockRejectedValue`, `mockThrow`, `mockReturnThis`)
+install an implementation on the host mock, and the dispatch that reads a `calledWith` chain **is**
+the implementation they replace — so the one written later wins outright and the other decides
+nothing, in either order, without failing. Both orders are now reported as a misconfiguration (a
+warning, a throw under the `strict` preset). Where both are wanted, the fallback goes in the spy's
+own container, which a chain still wins over: the `returns` option where the double is built, or
+`resolveWith` / `nextWith` / `failWith`. The report comes from this library's own spy engine — so
+Vitest and Rstest, not Bun or `node:test`, and not under `setSpyEngine('runner')` — and the `Once`
+family is never reported, because its queue drains back onto the dispatch.
+
 The failure prints both sides, because the diagnosis is the comparison rather than either half of
 it — and every configured call when there is more than one, matchers included, so a config that
 never matched is visible instead of inferred:
@@ -2371,8 +2382,14 @@ which shallow rendering touches.
 override keeps the component's own `imports` minus the child _components_, so the template renders
 with its own pipes and directives working while every child component in it resolves to nothing
 under `NO_ERRORS_SCHEMA`. (Before 5.4.0 the whole scope was dropped, which made a pipe in a kept
-template throw `NG0302` and an attribute directive silently never apply.) A child re-exported by an
-imported `NgModule` still renders — the module is kept whole. Reach for it when the spec reads
+template throw `NG0302` and an attribute directive silently never apply.) Those imports are read off
+`ɵcmp`, where the compiler leaves them in one of three shapes — the flat array, a factory returning
+it, or `null` for a component that imports nothing — and which one is not decided by JIT against
+AOT: JIT always emits the factory, AOT emits the array unless a cycle between two components forces
+it to defer the read. All three are handled; calling the array unconditionally was a
+`TypeError: dependencies is not a function` on an AOT-compiled component with no cycle in its
+imports. A child re-exported by an imported `NgModule` still renders — the module is kept whole.
+Reach for it when the spec reads
 something the template creates, and keep `keepChildren` for the handful of children it genuinely
 needs resolvable. Full write-up:
 [Performance](https://asdalexey.github.io/vitest-auto-spy/core/performance#_2-rendering-the-child-subtree).

package/dist/angular-router.js

@@ -1,4 +1,4 @@
-import { createFunctionSpy } from './chunk-NQNHA3R4.js';
+import { createFunctionSpy } from './chunk-MUJTPXMJ.js';
 import './chunk-OTOCFH6B.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 import { TestBed } from '@angular/core/testing';

package/dist/angular.js

@@ -74,6 +74,46 @@ function attachHelpers(target, helpers) {
   return target;
 }
 
+// src/lib/spy-mark.ts
+var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
+var DEEP_CHILDREN = /* @__PURE__ */ Symbol.for("vitest-auto-spy.deepChildren");
+function markAsMock(mock, mark = true) {
+  Object.defineProperty(mock, AUTO_SPY_MARK, { value: mark, enumerable: false, configurable: true });
+}
+function isMarkHooks(value) {
+  return typeof value === "object" && value !== null && "reset" in value && "clear" in value;
+}
+function hooksOf(mock) {
+  const mark = Reflect.get(mock, AUTO_SPY_MARK);
+  return isMarkHooks(mark) ? mark : void 0;
+}
+function isAutoSpyLike(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (AUTO_SPY_MARK in value) {
+    return true;
+  }
+  const accessorSpies = Reflect.get(value, "accessorSpies");
+  return typeof accessorSpies === "object" && accessorSpies !== null;
+}
+function isMarkedMock(value) {
+  return typeof value === "function" && AUTO_SPY_MARK in value;
+}
+function readDeepChildren(value) {
+  const children = Reflect.get(value, DEEP_CHILDREN);
+  if (!(children instanceof Map)) {
+    return [];
+  }
+  return [...children.values()].filter(isMarkedMock);
+}
+function runConfigReset(mock) {
+  hooksOf(mock)?.reset();
+}
+function runClearHook(mock) {
+  hooksOf(mock)?.clear();
+}
+
 // src/lib/spy-probe.ts
 var FAST_SPY_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.fastSpy");
 function isFastSpy(value) {
@@ -274,8 +314,12 @@ definePrototypeMember("getMockImplementation", function getMockImplementation()
   const config = configOf(self(this));
   return config.onceImplementations[0] ?? config.implementation;
 });
+function replaceImplementation(spy, implementation, via) {
+  hooksOf(spy)?.implementationReplaced?.(implementation, via);
+  configOf(spy).implementation = implementation;
+}
 definePrototypeMember("mockImplementation", function mockImplementation(implementation) {
-  configOf(self(this)).implementation = implementation;
+  replaceImplementation(self(this), implementation, "mockImplementation");
   return this;
 });
 definePrototypeMember("mockImplementationOnce", function mockImplementationOnce(implementation) {
@@ -307,18 +351,26 @@ definePrototypeMember(
   }
 );
 definePrototypeMember("mockReturnThis", function mockReturnThis() {
-  configOf(self(this)).implementation = function returnThis() {
-    return this;
-  };
+  replaceImplementation(
+    self(this),
+    function returnThis() {
+      return this;
+    },
+    "mockReturnThis"
+  );
   return this;
 });
 definePrototypeMember("mockReturnValue", function mockReturnValue(value) {
-  configOf(self(this)).implementation = function returnValue() {
-    if (new.target) {
-      throwConstructorError("mockReturnValue");
-    }
-    return value;
-  };
+  replaceImplementation(
+    self(this),
+    function returnValue() {
+      if (new.target) {
+        throwConstructorError("mockReturnValue");
+      }
+      return value;
+    },
+    "mockReturnValue"
+  );
   return this;
 });
 definePrototypeMember("mockReturnValueOnce", function mockReturnValueOnce(value) {
@@ -331,9 +383,13 @@ definePrototypeMember("mockReturnValueOnce", function mockReturnValueOnce(value)
   return this;
 });
 definePrototypeMember("mockThrow", function mockThrow(value) {
-  configOf(self(this)).implementation = function throwValue() {
-    throw value;
-  };
+  replaceImplementation(
+    self(this),
+    function throwValue() {
+      throw value;
+    },
+    "mockThrow"
+  );
   return this;
 });
 definePrototypeMember("mockThrowOnce", function mockThrowOnce(value) {
@@ -343,12 +399,16 @@ definePrototypeMember("mockThrowOnce", function mockThrowOnce(value) {
   return this;
 });
 definePrototypeMember("mockResolvedValue", function mockResolvedValue(value) {
-  configOf(self(this)).implementation = function resolvedValue() {
-    if (new.target) {
-      throwConstructorError("mockResolvedValue");
-    }
-    return Promise.resolve(value);
-  };
+  replaceImplementation(
+    self(this),
+    function resolvedValue() {
+      if (new.target) {
+        throwConstructorError("mockResolvedValue");
+      }
+      return Promise.resolve(value);
+    },
+    "mockResolvedValue"
+  );
   return this;
 });
 definePrototypeMember("mockResolvedValueOnce", function mockResolvedValueOnce(value) {
@@ -361,12 +421,16 @@ definePrototypeMember("mockResolvedValueOnce", function mockResolvedValueOnce(va
   return this;
 });
 definePrototypeMember("mockRejectedValue", function mockRejectedValue(value) {
-  configOf(self(this)).implementation = function rejectedValue() {
-    if (new.target) {
-      throwConstructorError("mockRejectedValue");
-    }
-    return Promise.reject(value);
-  };
+  replaceImplementation(
+    self(this),
+    function rejectedValue() {
+      if (new.target) {
+        throwConstructorError("mockRejectedValue");
+      }
+      return Promise.reject(value);
+    },
+    "mockRejectedValue"
+  );
   return this;
 });
 definePrototypeMember("mockRejectedValueOnce", function mockRejectedValueOnce(value) {
@@ -1067,6 +1131,17 @@ Actual: ${actualCall(functionName, actualArgs)}`;
   })
 };
 
+// src/lib/misconfiguration.ts
+function misconfigurationThrows() {
+  return globalThis.__vitestAutoSpyMisconfiguration__ === "throw";
+}
+function reportMisconfiguration(message) {
+  if (misconfigurationThrows()) {
+    throw new Error(message);
+  }
+  console.warn(message);
+}
+
 // src/lib/promise-spy.ts
 function toResolvedPerCallValues(valueConfigsPerCall) {
   return valueConfigsPerCall.map(
@@ -1147,46 +1222,6 @@ function installSettledResultsPolyfill(mockFn) {
   };
 }
 
-// src/lib/spy-mark.ts
-var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
-var DEEP_CHILDREN = /* @__PURE__ */ Symbol.for("vitest-auto-spy.deepChildren");
-function markAsMock(mock, mark = true) {
-  Object.defineProperty(mock, AUTO_SPY_MARK, { value: mark, enumerable: false, configurable: true });
-}
-function isMarkHooks(value) {
-  return typeof value === "object" && value !== null && "reset" in value && "clear" in value;
-}
-function hooksOf(mock) {
-  const mark = Reflect.get(mock, AUTO_SPY_MARK);
-  return isMarkHooks(mark) ? mark : void 0;
-}
-function isAutoSpyLike(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (AUTO_SPY_MARK in value) {
-    return true;
-  }
-  const accessorSpies = Reflect.get(value, "accessorSpies");
-  return typeof accessorSpies === "object" && accessorSpies !== null;
-}
-function isMarkedMock(value) {
-  return typeof value === "function" && AUTO_SPY_MARK in value;
-}
-function readDeepChildren(value) {
-  const children = Reflect.get(value, DEEP_CHILDREN);
-  if (!(children instanceof Map)) {
-    return [];
-  }
-  return [...children.values()].filter(isMarkedMock);
-}
-function runConfigReset(mock) {
-  hooksOf(mock)?.reset();
-}
-function runClearHook(mock) {
-  hooksOf(mock)?.clear();
-}
-
 // src/lib/function-spy.ts
 function isReturnValueContainer(value) {
   return typeof value === "object" && value !== null && "value" in value;
@@ -1299,6 +1334,24 @@ function returnTheCorrectFakeValue(state, actualArgs, functionName, unstubbed) {
   }
   return unwrapContainer(state.valueContainer);
 }
+function configuredChain(state) {
+  if (state.calledWith) {
+    return "calledWith";
+  }
+  return state.mustBeCalledWith ? "mustBeCalledWith" : void 0;
+}
+function dispatchReplacedMessage(name, via, chain, order) {
+  const what = order === "erased" ? `${via}() replaced the dispatch of '${name}' after ${chain}() was configured on it` : `${chain}() was configured on '${name}' after ${via}() had replaced its dispatch`;
+  return withDocs(
+    `[vitest-auto-spy] ${what}, so the ${chain}() decides nothing \u2014 every call answers what ${via}() installed. A fallback the ${chain}() still wins over goes in the spy's own container instead: the 'returns' option where the double is built, or resolveWith/nextWith/failWith.`,
+    DOCS_LINKS.createSpyFromClass
+  );
+}
+function reportLateChain(internals, chain) {
+  if (internals.replacedBy !== void 0) {
+    reportMisconfiguration(dispatchReplacedMessage(internals.name, internals.replacedBy, chain, "late"));
+  }
+}
 function addMethodsToCalledWith(calledWith, calledWithArgs) {
   const setReturnValue = (value) => {
     calledWith.argsToValuesMap.set(calledWithArgs, { value });
@@ -1325,14 +1378,37 @@ function ensureCalledWithObject(state, chain) {
   return created;
 }
 var FunctionSpyInternals = class {
-  /** Built on the first stream helper, not on every spy — see {@link ObservableSupport.streamForFunctionSpy}. */
-  #observable = void 0;
-  constructor(state, valueContainer, host, dispatch, recorder) {
+  constructor(state, valueContainer, host, dispatch, recorder, name) {
+    /** Built on the first stream helper, not on every spy — see {@link ObservableSupport.streamForFunctionSpy}. */
+    this.#observable = void 0;
+    /** The member that last installed an implementation of the host's own over the dispatch, if any. */
+    this.replacedBy = void 0;
     this.state = state;
     this.valueContainer = valueContainer;
     this.host = host;
     this.dispatch = dispatch;
     this.recorder = recorder;
+    this.name = name;
+  }
+  #observable;
+  /**
+   * A host implementation went in over the dispatch — reported when it silently disables a
+   * `calledWith` chain this spy already carries, and remembered so that a chain configured
+   * afterwards can say the same thing (see {@link SPY_HELPERS}).
+   *
+   * Re-installing the dispatch itself is the opposite move — `resetAutoSpy` and the jasmine
+   * namespace both do it — so it clears the flag instead of raising one.
+   */
+  implementationReplaced(implementation, via) {
+    if (implementation === this.dispatch) {
+      this.replacedBy = void 0;
+      return;
+    }
+    this.replacedBy = via;
+    const chain = configuredChain(this.state);
+    if (chain !== void 0) {
+      reportMisconfiguration(dispatchReplacedMessage(this.name, via, chain, "erased"));
+    }
   }
   /**
    * The rxjs layer's state for this spy, materialised on first use.
@@ -1361,6 +1437,7 @@ var FunctionSpyInternals = class {
     delete valueContainer.valuesPerCalls;
     this.#observable?.reset();
     getMockAdapter().restoreImplementation(this.host, this.dispatch);
+    this.replacedBy = void 0;
   }
   /** Empties the polyfilled `settledResults` on `clearAutoSpy` / `resetAutoSpy` (a no-op on Vitest, where the host clears its native array). */
   clear() {
@@ -1402,13 +1479,14 @@ var SPY_HELPERS = /* @__PURE__ */ Object.assign(
       valueContainer.valuesPerCalls = [];
     },
     calledWith(...calledWithArgs) {
-      return addMethodsToCalledWith(ensureCalledWithObject(internalsOf(this, "calledWith").state, "calledWith"), calledWithArgs);
+      const internals = internalsOf(this, "calledWith");
+      reportLateChain(internals, "calledWith");
+      return addMethodsToCalledWith(ensureCalledWithObject(internals.state, "calledWith"), calledWithArgs);
     },
     mustBeCalledWith(...calledWithArgs) {
-      return addMethodsToCalledWith(
-        ensureCalledWithObject(internalsOf(this, "mustBeCalledWith").state, "mustBeCalledWith"),
-        calledWithArgs
-      );
+      const internals = internalsOf(this, "mustBeCalledWith");
+      reportLateChain(internals, "mustBeCalledWith");
+      return addMethodsToCalledWith(ensureCalledWithObject(internals.state, "mustBeCalledWith"), calledWithArgs);
     }
   }
 );
@@ -1423,7 +1501,7 @@ function createFunctionSpy(name, unstubbed) {
   const functionSpy = getMockAdapter().createMockFn(dispatch, name);
   const recorder = installSettledResultsPolyfill(functionSpy);
   settledResultsRecorder = recorder.record;
-  const internals = new FunctionSpyInternals(state, valueContainer, functionSpy, dispatch, recorder);
+  const internals = new FunctionSpyInternals(state, valueContainer, functionSpy, dispatch, recorder, name);
   const spy = attachHelpers(functionSpy, SPY_HELPERS);
   getObservableSupport()?.addToFunctionSpy(spy);
   getJasmineSupport()?.addToFunctionSpy(spy, {
@@ -1439,17 +1517,6 @@ function exposeAsSpy(spy) {
   return spy;
 }
 
-// src/lib/misconfiguration.ts
-function misconfigurationThrows() {
-  return globalThis.__vitestAutoSpyMisconfiguration__ === "throw";
-}
-function reportMisconfiguration(message) {
-  if (misconfigurationThrows()) {
-    throw new Error(message);
-  }
-  console.warn(message);
-}
-
 // src/lib/proxy-props.ts
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
@@ -3222,7 +3289,8 @@ function isStandalone3(definition2) {
 }
 function importsOf(definition2) {
   const dependencies = Reflect.get(definition2, "dependencies");
-  return dependencies();
+  const resolved = typeof dependencies === "function" ? dependencies() : dependencies;
+  return Array.isArray(resolved) ? resolved : NOTHING;
 }
 function isChildComponent(dependency) {
   return Reflect.get(dependency, "\u0275cmp") !== void 0;

package/dist/bun-angular.js

@@ -1,16 +1,17 @@
 import { stable, flushEffects } from './chunk-M5BULP7X.js';
 export { flushEffects, stable } from './chunk-M5BULP7X.js';
 import './chunk-M6VMOOZ2.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-JOI3BLCL.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
 import { currentSpecFile, mockValueProp } from './chunk-N3T7KWWA.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-import { createSpyForToken } from './chunk-HXH2QXK2.js';
-import { createSpyFromClass } from './chunk-F334GPEI.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-F334GPEI.js';
-import { misconfigurationThrows, reportMisconfiguration } from './chunk-HZPV3CHD.js';
+import { createSpyForToken } from './chunk-RPEYIZPL.js';
+import { createSpyFromClass } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-NQNHA3R4.js';
+import { misconfigurationThrows, reportMisconfiguration } from './chunk-MUJTPXMJ.js';
+export { createFunctionSpy, errorHandler } from './chunk-MUJTPXMJ.js';
 import { isAutoSpyLike } from './chunk-OTOCFH6B.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 import '@angular/compiler';
@@ -310,7 +311,8 @@ function isStandalone(definition) {
 }
 function importsOf(definition) {
   const dependencies = Reflect.get(definition, "dependencies");
-  return dependencies();
+  const resolved = typeof dependencies === "function" ? dependencies() : dependencies;
+  return Array.isArray(resolved) ? resolved : NOTHING;
 }
 function isChildComponent(dependency) {
   return Reflect.get(dependency, "\u0275cmp") !== void 0;

package/dist/bun.js

@@ -1,10 +1,10 @@
 import './chunk-M6VMOOZ2.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-JOI3BLCL.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-F334GPEI.js';
-import './chunk-HZPV3CHD.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-NQNHA3R4.js';
+export { createFunctionSpy, errorHandler } from './chunk-MUJTPXMJ.js';
 import './chunk-OTOCFH6B.js';
 import './chunk-Q477VHHF.js';

package/dist/{chunk-BDJYPKLB.js → chunk-33NJHIS2.js}

@@ -1,6 +1,6 @@
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-NQNHA3R4.js';
-import { setSharedHelperSink } from './chunk-OTOCFH6B.js';
+import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-MUJTPXMJ.js';
+import { setSharedHelperSink, hooksOf } from './chunk-OTOCFH6B.js';
 
 // src/lib/spy-engine.ts
 var sharedEngine;
@@ -202,8 +202,12 @@ definePrototypeMember("getMockImplementation", function getMockImplementation()
   const config = configOf(self(this));
   return config.onceImplementations[0] ?? config.implementation;
 });
+function replaceImplementation(spy, implementation, via) {
+  hooksOf(spy)?.implementationReplaced?.(implementation, via);
+  configOf(spy).implementation = implementation;
+}
 definePrototypeMember("mockImplementation", function mockImplementation(implementation) {
-  configOf(self(this)).implementation = implementation;
+  replaceImplementation(self(this), implementation, "mockImplementation");
   return this;
 });
 definePrototypeMember("mockImplementationOnce", function mockImplementationOnce(implementation) {
@@ -235,18 +239,26 @@ definePrototypeMember(
   }
 );
 definePrototypeMember("mockReturnThis", function mockReturnThis() {
-  configOf(self(this)).implementation = function returnThis() {
-    return this;
-  };
+  replaceImplementation(
+    self(this),
+    function returnThis() {
+      return this;
+    },
+    "mockReturnThis"
+  );
   return this;
 });
 definePrototypeMember("mockReturnValue", function mockReturnValue(value) {
-  configOf(self(this)).implementation = function returnValue() {
-    if (new.target) {
-      throwConstructorError("mockReturnValue");
-    }
-    return value;
-  };
+  replaceImplementation(
+    self(this),
+    function returnValue() {
+      if (new.target) {
+        throwConstructorError("mockReturnValue");
+      }
+      return value;
+    },
+    "mockReturnValue"
+  );
   return this;
 });
 definePrototypeMember("mockReturnValueOnce", function mockReturnValueOnce(value) {
@@ -259,9 +271,13 @@ definePrototypeMember("mockReturnValueOnce", function mockReturnValueOnce(value)
   return this;
 });
 definePrototypeMember("mockThrow", function mockThrow(value) {
-  configOf(self(this)).implementation = function throwValue() {
-    throw value;
-  };
+  replaceImplementation(
+    self(this),
+    function throwValue() {
+      throw value;
+    },
+    "mockThrow"
+  );
   return this;
 });
 definePrototypeMember("mockThrowOnce", function mockThrowOnce(value) {
@@ -271,12 +287,16 @@ definePrototypeMember("mockThrowOnce", function mockThrowOnce(value) {
   return this;
 });
 definePrototypeMember("mockResolvedValue", function mockResolvedValue(value) {
-  configOf(self(this)).implementation = function resolvedValue() {
-    if (new.target) {
-      throwConstructorError("mockResolvedValue");
-    }
-    return Promise.resolve(value);
-  };
+  replaceImplementation(
+    self(this),
+    function resolvedValue() {
+      if (new.target) {
+        throwConstructorError("mockResolvedValue");
+      }
+      return Promise.resolve(value);
+    },
+    "mockResolvedValue"
+  );
   return this;
 });
 definePrototypeMember("mockResolvedValueOnce", function mockResolvedValueOnce(value) {
@@ -289,12 +309,16 @@ definePrototypeMember("mockResolvedValueOnce", function mockResolvedValueOnce(va
   return this;
 });
 definePrototypeMember("mockRejectedValue", function mockRejectedValue(value) {
-  configOf(self(this)).implementation = function rejectedValue() {
-    if (new.target) {
-      throwConstructorError("mockRejectedValue");
-    }
-    return Promise.reject(value);
-  };
+  replaceImplementation(
+    self(this),
+    function rejectedValue() {
+      if (new.target) {
+        throwConstructorError("mockRejectedValue");
+      }
+      return Promise.reject(value);
+    },
+    "mockRejectedValue"
+  );
   return this;
 });
 definePrototypeMember("mockRejectedValueOnce", function mockRejectedValueOnce(value) {

package/dist/{chunk-JOI3BLCL.js → chunk-ADBB2HQG.js}

@@ -1,9 +1,9 @@
 import { mockValueProp, mockAccessorsProp } from './chunk-N3T7KWWA.js';
-import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-F334GPEI.js';
-import { resolveReadGuard, createTrackedPropSpy } from './chunk-HZPV3CHD.js';
+import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-BWT7U4V4.js';
+import { resolveReadGuard, createTrackedPropSpy } from './chunk-OS4PTU6D.js';
 import { redefineFailure } from './chunk-DTZCPCMA.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defineHelper, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-NQNHA3R4.js';
+import { defineHelper, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-MUJTPXMJ.js';
 import { DEEP_CHILDREN } from './chunk-OTOCFH6B.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 import { getMockAdapter, emissionTimeout } from './shared-state.js';

package/dist/{chunk-F334GPEI.js → chunk-BWT7U4V4.js}

@@ -1,6 +1,6 @@
-import { resolveReadGuard, createTrackedPropSpy, reportMisconfiguration, unconfiguredGetter } from './chunk-HZPV3CHD.js';
+import { resolveReadGuard, createTrackedPropSpy, unconfiguredGetter } from './chunk-OS4PTU6D.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { resolveUnstubbedGuard, seedReturnValue, createFunctionSpy } from './chunk-NQNHA3R4.js';
+import { resolveUnstubbedGuard, reportMisconfiguration, seedReturnValue, createFunctionSpy } from './chunk-MUJTPXMJ.js';
 import { runClearHook, runConfigReset, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-OTOCFH6B.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 import { getMockAdapter, getJasmineSupport } from './shared-state.js';