vitest-auto-spy 5.13.0 → 5.15.0

package/AGENTS.md

@@ -201,6 +201,23 @@ asSpy<AppLogger>(logger.channel('app')).info.mockReturnValue(undefined); // →
 `asInstance` did not take a deep mock before 3.5.0, which left it with nowhere to go: this tree
 sends you to `mockDeep` when the calls chain, and the result then fitted nothing that expected `T`.
 
+**`selfReturning: true` chains a factory, not a `return this` builder**, and the difference decides
+where the calls are recorded. A called node answers _itself_, not the object the method was read
+off, so every hop moves one level deeper: `editor.chain().focus().insertContent('text')` records
+`insertContent` on `chain.focus`, while the `chain` handle the spec is holding still has none — and
+`expect(chain.insertContent).toHaveBeenCalled()` reports nothing although the chain ran. Either walk
+the same path in the assertion, or, for an API where every command answers the **same** object
+(tiptap's `ChainedCommands`, a query builder, a `mockReturnThis()` chain), build that object with
+`createAutoMock` instead, where `selfReturning` names methods that answer one double:
+
+```ts
+const chain = createAutoMock<ChainedCommands>(undefined, { selfReturning: ['focus', 'insertContent'] });
+const editor = createAutoMock<Editor>(undefined, { returns: { chain: asInstance(chain) } });
+
+editor.chain().focus().insertContent('text').run();
+expect(chain.insertContent).toHaveBeenCalledWith('text'); // one double, so the assertion is the obvious one
+```
+
 **An `abstract class` is a class.** `abstract class LocalStorage extends AbstractStorage {}`,
 provided in production as `{ provide: LocalStorage, useClass: BrowserLocalStorage }`, is the
 standard Angular DI-token idiom, and `provideAutoSpy(LocalStorage)` / `createSpyFromClass(LocalStorage)`
@@ -231,6 +248,13 @@ createAutoMock<NavigationService>({ currentFocus: undefined, navRoot: undefined,
 This is the way to say "the member exists and is empty", and it is worth writing even when it looks
 redundant.
 
+**A getter in `overrides` stays a getter.** The seed is kept as a descriptor rather than read once
+while the double is assembled, so it runs at every read, with the double as `this` — and a seed
+written to **throw** ("this global is missing on this platform") fails where the code under test
+reads the member, not where the provider literal is evaluated. A `{ set }` seed is kept the same way
+and takes the write. Both used to be flattened as the double was built, which turned a throwing
+seed into a failure during `TestBed.configureTestingModule`, three frames from the branch under test.
+
 ### What a Proxy-backed double cannot do
 
 `createAutoMock` and `mockDeep` build a Proxy, not an object, and there is one place where the
@@ -3148,7 +3172,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-create-spy-from-class`    | `error` | —                 | an object literal of 2+ `vi.fn()`s → `createSpyFromClass` (a factory's own seed is exempt)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `no-stub-class-double`            | `warn`  | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy` and delete the stub; a decorated, `implements`-ing, `extends`-ing or unnamed class is exempt — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `no-structural-double`            | `warn`  | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`; a bare `let fn: Mock` is a callback and never reported — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `prefer-inject-spy`               | `error` | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, inline or via a `const` → `injectSpy(X).m`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `prefer-inject-spy`               | `error` | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, inline or via a `const` → `injectSpy(X).m`; `ApplicationRef`, `DestroyRef`, `EnvironmentInjector`, `HttpClient` and `Injector` keep their real instance — option: `{ ignoreTokens }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `no-shared-module-level-mock`     | `error` | —                 | an **exported** value holding `vi.fn()`s → export a factory instead                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `no-mocked-for-spy`               | `error` | `--fix` / suggest | `Mocked<T>` in any type position → `Spy<T>`, import and all — a suggestion where the assigned value is not from a factory of this library                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `prefer-as-spy`                   | `error` | `--fix`           | `TestBed.inject(X) as Spy<X>` → `asSpy<X>(TestBed.inject(X))`, import and all                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
@@ -3311,6 +3335,15 @@ The variable is resolved through the scope manager, so it has to be a `const`/`l
 from `TestBed.inject(...)` and never assigned again — a name bound by an import, a parameter, or a
 `let` that is reassigned is left alone.
 
+Five tokens are left alone whatever is spied on them: `ApplicationRef`, `DestroyRef`,
+`EnvironmentInjector`, `HttpClient`, `Injector`. Each is a case where this rule's advice is
+impossible or self-defeating — `{ provide: DestroyRef, useValue }` is silently ignored, because
+`R3Injector.get()` short-circuits on `__NG_ENV_ID__` before it reads its providers; a spied
+`ApplicationRef` has no `injector` to build a component with; `HttpClient` under
+`provideHttpClientTesting()` is supposed to be real. A project adds its own with
+`['error', { ignoreTokens: ['MapRendererService'] }]`, compared as source text, which extends the
+five rather than replacing them.
+
 `no-inject-before-override` catches the trap this plugin's own advice sets. `TestBed.inject()` in a
 `beforeEach` — the line you write once `provideAutoSpy(X)` has taken away the literal you used to
 configure — instantiates the module, and every `TestBed.override*` afterwards throws, including one

package/README.md

@@ -2027,6 +2027,22 @@ expect(svc.apiUrl).toBe('https://api.test'); // or assign: svc.apiUrl = '...'
 > access — an un-seeded property read returns a spy. Seed real property values via `overrides`
 > (or assignment) to get them back verbatim.
 
+**A getter in `overrides` stays a getter.** The seed keeps its descriptor, so an accessor is
+installed as one and runs at the read — once per read, with the double as `this` — and a `{ set }`
+seed takes the write. That is what a seed written to _throw_ needs: "this global is missing on this
+platform" fails where the code under test reads the member, not while the provider literal is being
+evaluated.
+
+```ts
+const platform = createAutoMock<PlatformSupport>({
+  get transceiver(): never {
+    throw new TypeError('RTCRtpTransceiver is not defined');
+  },
+});
+
+expect(() => platform.transceiver).toThrow(); // at the read, not at `TestBed.configureTestingModule`
+```
+
 For a double the code under test only **reads** — a DTO, a route snapshot, a config object — that
 caveat is the wrong trade, and [`createMock<T>()`](#utilities) is the other half of the pair: it
 returns a plain `T` built from the fields you seed, with no spies anywhere.
@@ -3427,7 +3443,7 @@ export can never be.
 | `prefer-create-spy-from-class`    |   `error`   | —                 | an object literal of two or more `vi.fn()`s → `createSpyFromClass` / `createAutoMock`, unless it is a factory's own seed                                                                                                                                                                                                                                                                                                                                                                                         |
 | `no-stub-class-double`            |   `warn`    | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy`, the stub class deleted                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `no-structural-double`            |   `warn`    | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `prefer-inject-spy`               |   `error`   | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, in one step or two → `injectSpy(X).m`                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `prefer-inject-spy`               |   `error`   | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, in one step or two → `injectSpy(X).m`; `ApplicationRef`, `DestroyRef`, `EnvironmentInjector`, `HttpClient` and `Injector` keep their real instance — option: `{ ignoreTokens }`                                                                                                                                                                                                                                                                                              |
 | `no-object-define-property`       |   `error`   | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `no-expect-in-subscribe`          |   `error`   | suggest           | `expect()` inside a `subscribe()` callback → `expectEmission` / `firstValueFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `no-shared-module-level-mock`     |   `error`   | —                 | an **exported** value holding `vi.fn()`s → export a factory that returns it                                                                                                                                                                                                                                                                                                                                                                                                                                      |

package/dist/angular.js

@@ -1521,7 +1521,12 @@ function exposeAsSpy(spy) {
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }

package/dist/bun-angular.js

@@ -1,12 +1,12 @@
 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-ADBB2HQG.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-63S25O6W.js';
 import { currentSpecFile, mockValueProp } from './chunk-N3T7KWWA.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.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 { createSpyForToken } from './chunk-I6AIKRUJ.js';
+import { createSpyFromClass } from './chunk-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/bun.d.ts

@@ -248,6 +248,13 @@ interface MockDeepOptions {
      * ```ts
      * asSpy<QueryBuilder>(query.where('id')).limit.mockReturnValue(query);
      * ```
+     *
+     * **A called node answers itself, not its receiver**, which is the difference between a factory
+     * and a `return this` builder. `editor.chain().focus().insertContent('x')` therefore records
+     * `insertContent` on `chain.focus`, while the `chain` handle the spec holds has no calls at all —
+     * the obvious assertion reports nothing although the chain ran. Assert down the path the chain
+     * walked, or build the object with `createAutoMock<T>(undefined, { selfReturning: ['focus', …] })`,
+     * where the named methods answer one double, which is what an API of this shape does.
      */
     selfReturning?: boolean;
 }

package/dist/bun.js

@@ -1,7 +1,7 @@
 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-ADBB2HQG.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-63S25O6W.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/{chunk-ADBB2HQG.js → chunk-63S25O6W.js}

@@ -1,5 +1,5 @@
 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-BWT7U4V4.js';
+import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-C3EFC33U.js';
 import { resolveReadGuard, createTrackedPropSpy } from './chunk-OS4PTU6D.js';
 import { redefineFailure } from './chunk-DTZCPCMA.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';

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

@@ -72,7 +72,12 @@ function attachDispose(spy) {
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }

package/dist/{chunk-RPEYIZPL.js → chunk-I6AIKRUJ.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-BWT7U4V4.js';
+import { createSpyFromClass, createAutoMock } from './chunk-C3EFC33U.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 
 // src/lib/track-injections.ts

package/dist/cli.js

@@ -2455,7 +2455,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.13.0";
+var EXPORT_MAP_VERSION = "5.15.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 17 18 19",
@@ -4312,6 +4312,17 @@ var NO_PER_TEST = "\u2014";
 var INDENT = "  ";
 var GAP = 4;
 var ELLIPSIS = "\u2026";
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var OFF = "\x1B[0m";
+var MONOCHROME = { red: (text) => text, dim: (text) => text };
+var TERMINAL = {
+  red: (text) => `${RED}${text}${OFF}`,
+  dim: (text) => `${DIM}${text}${OFF}`
+};
+function colorWanted(env) {
+  return env["NO_COLOR"] === void 0 && env["FORCE_COLOR"] !== "0" && env["TERM"] !== "dumb";
+}
 function fileHotspots(run, cwd, limit) {
   const found = [];
   for (const [file, measured] of measuredFiles(run, cwd)) {
@@ -4338,28 +4349,58 @@ function caseHotspots(run, cwd, limit) {
 function totalTestMs(run, cwd) {
   return [...measuredFiles(run, cwd).values()].reduce((total, file) => total + file.tests, 0);
 }
-function truncateLeft(text, width) {
-  return text.length <= width ? text : `${ELLIPSIS}${text.slice(text.length - width + ELLIPSIS.length)}`;
+function truncateLeft(text, width, paint) {
+  if (text.length <= width) {
+    return text;
+  }
+  return `${paint.dim(ELLIPSIS)}${text.slice(text.length - width + ELLIPSIS.length)}`;
+}
+function truncatePath(path, width, paint) {
+  if (path.length <= width) {
+    return path;
+  }
+  const first = path.indexOf("/");
+  if (first === -1) {
+    return truncateLeft(path, width, paint);
+  }
+  const head = path.slice(0, first);
+  const rest = path.slice(first + 1).split("/");
+  const budget = width - head.length - 3;
+  const tail = [];
+  let used = 0;
+  for (const segment of [...rest].reverse()) {
+    const next = used === 0 ? segment.length : used + 1 + segment.length;
+    if (next > budget) {
+      break;
+    }
+    tail.unshift(segment);
+    used = next;
+  }
+  if (tail.length === 0) {
+    return truncateLeft(path, width, paint);
+  }
+  return `${head}/${paint.dim(ELLIPSIS)}/${tail.join("/")}`;
 }
 function widthOf(head, cells) {
   return cells.reduce((widest, cell) => Math.max(widest, cell.length), head.length);
 }
-function table(label, numbers, width) {
+function table(label, numbers, width, truncate, decorate) {
   const spent = numbers.reduce((sum, column) => sum + widthOf(column.head, column.cells) + GAP, 0);
   const labelWidth = Math.max(Math.min(widthOf(label.head, label.cells), width - INDENT.length - spent), label.head.length);
   const laid = [
-    { width: labelWidth, left: true, texts: [label.head, ...label.cells.map((cell) => truncateLeft(cell, labelWidth))] },
+    { width: labelWidth, left: true, texts: [label.head, ...label.cells.map((cell) => truncate(cell, labelWidth))] },
     ...numbers.map((column) => ({ width: widthOf(column.head, column.cells) + GAP, left: false, texts: [column.head, ...column.cells] }))
   ];
   return laid.reduce(
-    (lines, column) => column.texts.map(
-      (text, index) => `${lines[index] ?? INDENT}${column.left ? text.padEnd(column.width) : text.padStart(column.width)}`
+    (lines, column, current) => column.texts.map(
+      (text, index) => `${lines[index] ?? INDENT}${decorate(index, current, column.left ? text.padEnd(column.width) : text.padStart(column.width))}`
     ),
     []
   ).join("\n");
 }
-function fileSection(files, total, width) {
+function fileSection(files, total, width, floorMs, paint) {
   const listed = files.reduce((sum, hotspot) => sum + hotspot.ms, 0);
+  const overBudget = new Set(files.flatMap((hotspot, index) => hotspot.testCount > 0 && hotspot.perTest >= floorMs ? [index + 1] : []));
   const drawn = table(
     { head: "file", cells: files.map((hotspot) => hotspot.file) },
     [
@@ -4367,7 +4408,9 @@ function fileSection(files, total, width) {
       { head: "ms/test", cells: files.map((hotspot) => hotspot.testCount === 0 ? NO_PER_TEST : formatMs(hotspot.perTest)) },
       { head: "share", cells: files.map((hotspot) => formatShare(hotspot.ms / total)) }
     ],
-    width
+    width,
+    (cell, columnWidth) => truncatePath(cell, columnWidth, paint),
+    (row, column, padded) => row === 0 ? paint.dim(padded) : column === 2 && overBudget.has(row) ? paint.red(padded) : padded
   );
   const counted = files.length === 1 ? "That one file is" : `Those ${files.length} files are`;
   const prose = [
@@ -4377,27 +4420,51 @@ function fileSection(files, total, width) {
   ].join("\n");
   return ["slowest files \u2014 what every body in the file cost, and what one of them cost", drawn, prose];
 }
-function caseSection(cases, width) {
+function caseSection(cases, width, floorMs, paint) {
   if (cases.length === 0) {
     return [];
   }
+  const timeWidth = widthOf(
+    "time",
+    cases.map((entry) => formatMs(entry.ms))
+  ) + GAP;
+  const nameWidth = Math.max(width - 2 * INDENT.length - timeWidth, "test".length);
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of cases) {
+    const bucket = groups.get(entry.file);
+    bucket === void 0 ? groups.set(entry.file, [entry]) : bucket.push(entry);
+  }
+  const lines = [];
+  for (const [file, entries] of groups) {
+    lines.push(`${INDENT}${truncatePath(file, width - INDENT.length, paint)}`);
+    for (const entry of entries) {
+      const time = formatMs(entry.ms).padStart(timeWidth);
+      lines.push(
+        `${INDENT}${INDENT}${truncateLeft(entry.name, nameWidth, paint).padEnd(nameWidth)}${entry.ms >= floorMs ? paint.red(time) : time}`
+      );
+    }
+  }
   return [
     `slowest test bodies \u2014 a body under ${formatMs(CASE_FLOOR_MS)} is not in the report at all, so a fast one is absent rather than cheap`,
-    table(
-      { head: "test", cells: cases.map((entry) => `${entry.file} \u203A ${entry.name}`) },
-      [{ head: "time", cells: cases.map((entry) => formatMs(entry.ms)) }],
-      width
-    )
+    lines.join("\n")
   ];
 }
 function formatHotspots(run, cwd, options = {}) {
-  const { limit, floorMs, width } = { ...HOTSPOT_DEFAULTS, ...options };
+  const { limit, floorMs, width, colors } = { ...HOTSPOT_DEFAULTS, ...options };
+  const paint = withColors(colors ?? colorWanted(process.env));
   const files = fileHotspots(run, cwd, limit);
   const [slowest] = files;
   if (slowest === void 0 || slowest.ms < floorMs) {
     return "";
   }
-  return [...fileSection(files, totalTestMs(run, cwd), width), ...caseSection(caseHotspots(run, cwd, limit), width)].join("\n\n");
+  const sections = [
+    ...fileSection(files, totalTestMs(run, cwd), width, floorMs, paint),
+    ...caseSection(caseHotspots(run, cwd, limit), width, floorMs, paint)
+  ];
+  return sections.join("\n\n");
+}
+function withColors(on) {
+  return on ? TERMINAL : MONOCHROME;
 }
 function hotspotFloorNote(run, cwd, floorMs = HOTSPOT_DEFAULTS.floorMs) {
   const [slowest] = fileHotspots(run, cwd, 1);

package/dist/eslint-plugin.cjs

@@ -952,6 +952,23 @@ function injectedFromVariable(context, target) {
   const initializer = initializerOf(context.sourceCode.getScope(target), target);
   return initializer && isTestBedInject(initializer) ? initializer : void 0;
 }
+var KEPT_REAL_TOKENS = ["ApplicationRef", "DestroyRef", "EnvironmentInjector", "HttpClient", "Injector"];
+var INJECTED_SPY_SCHEMA = [
+  {
+    type: "object",
+    properties: { ignoreTokens: { type: "array", items: { type: "string" }, uniqueItems: true } },
+    additionalProperties: false
+  }
+];
+function keepsTheRealInstance(context, injectCall) {
+  const [token] = injectCall.arguments;
+  if (!token) {
+    return false;
+  }
+  const text = context.sourceCode.getText(token);
+  const configured = Reflect.get(Object(context.options[0]), "ignoreTokens");
+  return KEPT_REAL_TOKENS.includes(text) || Array.isArray(configured) && configured.includes(text);
+}
 function memberName2(node) {
   const value = node?.type === "Literal" ? Reflect.get(node, "value") : void 0;
   return typeof value === "string" && /^[$A-Z_a-z][\w$]*$/.test(value) ? value : void 0;
@@ -3007,8 +3024,9 @@ var preferInjectSpy = defineRule({
   anchor: "-reading-a-spy-back-from-di",
   description: "Read an already-spied dependency with injectSpy() instead of re-spying a TestBed.inject() result",
   hasSuggestions: true,
+  schema: INJECTED_SPY_SCHEMA,
   messages: {
-    preferInjectSpy: "Spying the instance DI just handed you replaces one method and leaves the rest real. Provide it with `provideAutoSpy(X)` and read it back with `injectSpy(X)`."
+    preferInjectSpy: "Spying the instance DI just handed you replaces one method and leaves the rest real. Provide it with `provideAutoSpy(X)` and read it back with `injectSpy(X)`. When the real instance is what the spec came for \u2014 the spy holds one method of an object whose other half has to keep working, or the token cannot be substituted at all, as `DestroyRef` cannot (it carries `__NG_ENV_ID__`, so `R3Injector.get()` answers before it reads its own providers and `{ provide: DestroyRef, useValue }` is silently ignored) \u2014 that token belongs in `{ ignoreTokens: [...] }`, which is a statement about the token and survives the next edit, rather than behind a per-line disable."
   },
   create: (context) => ({
     'CallExpression[callee.object.name="vi"][callee.property.name="spyOn"]': (node) => {
@@ -3017,7 +3035,7 @@ var preferInjectSpy = defineRule({
         return;
       }
       const injectCall = isTestBedInject(target) ? target : injectedFromVariable(context, target);
-      if (!injectCall) {
+      if (!injectCall || keepsTheRealInstance(context, injectCall)) {
         return;
       }
       const suggestion = injectSpySuggestion(context, node, injectCall);

package/dist/index.js

@@ -1502,7 +1502,12 @@ function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn, reads) {
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }

package/dist/jasmine.js

@@ -1,7 +1,7 @@
 import { useVitestAdapter } from './chunk-PA4ZNLNZ.js';
 import { enableJasmineCompat } from './chunk-MAKQSO2R.js';
 export { enableJasmineCompat } from './chunk-MAKQSO2R.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
+import { createSpyFromClass } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/nestjs.js

@@ -1,6 +1,6 @@
-import { createSpyForToken } from './chunk-RPEYIZPL.js';
-export { trackInjections } from './chunk-RPEYIZPL.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
+import { createSpyForToken } from './chunk-I6AIKRUJ.js';
+export { trackInjections } from './chunk-I6AIKRUJ.js';
+import { createSpyFromClass } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/node.cjs

@@ -1222,7 +1222,12 @@ var DISPOSE = installDisposeSymbol(Symbol);
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }

package/dist/node.js

@@ -1,6 +1,6 @@
-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 { 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-63S25O6W.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import { guardAccessorSpies, createRedefineMockAdapter } from './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/react.js

@@ -1,6 +1,6 @@
-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 { 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-63S25O6W.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/rstest.js

@@ -1,6 +1,6 @@
-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 { 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-63S25O6W.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-33NJHIS2.js';
 import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-DTZCPCMA.js';

package/dist/svelte.js

@@ -1,6 +1,6 @@
-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 { 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-63S25O6W.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/vue.js

@@ -1,7 +1,7 @@
-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 { 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-63S25O6W.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+import { createSpyFromClass } from './chunk-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/package.json

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