vitest-auto-spy 3.15.0 → 3.15.1

package/README.md

@@ -19,7 +19,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.9%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-15.1%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)

package/dist/angular.js

@@ -380,6 +380,14 @@ Actual: ${actualCall(functionName, actualArgs)}`;
 };
 
 // src/lib/spy-decoration.ts
+function detachedHelperError(helper) {
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] ${helper} was called off its spy: \`const { ${helper} } = spy.method\` loses the spy it configures. Call it as a method \u2014 spy.method.${helper}(\u2026) \u2014 or bind it first.`,
+      DOCS_LINKS.controlHelpers
+    )
+  );
+}
 function decorate(target, helpers) {
   return Object.assign(target, helpers);
 }
@@ -390,34 +398,35 @@ function toResolvedPerCallValues(valueConfigsPerCall) {
     wrappedValue: config.delay === void 0 ? Promise.resolve(config.value) : new Promise((resolve) => setTimeout(() => resolve(config.value), config.delay))
   }));
 }
-function addPromiseHelpers(target, store) {
-  decorate(target, {
-    resolveWith: (value) => {
-      store({ value: Promise.resolve(value) });
+function promiseHelpers(store) {
+  return {
+    resolveWith(value) {
+      store(this, { value: Promise.resolve(value) }, "resolveWith");
     },
-    rejectWith: (value) => {
-      store({ value, _isRejectedPromise: true });
+    rejectWith(value) {
+      store(this, { value, _isRejectedPromise: true }, "rejectWith");
     },
-    resolveWithPerCall: (valueConfigsPerCall) => {
+    resolveWithPerCall(valueConfigsPerCall) {
       if (valueConfigsPerCall.length === 0) {
         return;
       }
-      store({ value: void 0, valuesPerCalls: toResolvedPerCallValues(valueConfigsPerCall) });
+      store(this, { value: void 0, valuesPerCalls: toResolvedPerCallValues(valueConfigsPerCall) }, "resolveWithPerCall");
     }
-  });
+  };
 }
-function addPromiseHelpersToFunctionSpy(spyFunction, valueContainer) {
-  addPromiseHelpers(spyFunction, (container) => {
-    valueContainer.value = container.value;
-    valueContainer._isRejectedPromise = container._isRejectedPromise ?? false;
-    valueContainer._isThrown = false;
-    valueContainer.valuesPerCalls = container.valuesPerCalls ?? [];
-  });
+function storePromiseConfig(valueContainer, container) {
+  valueContainer.value = container.value;
+  valueContainer._isRejectedPromise = container._isRejectedPromise ?? false;
+  valueContainer._isThrown = false;
+  valueContainer.valuesPerCalls = container.valuesPerCalls ?? [];
 }
 function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
-  addPromiseHelpers(calledWithObject, (container) => {
-    calledWithObject.argsToValuesMap.set(calledWithArgs, container);
-  });
+  decorate(
+    calledWithObject,
+    promiseHelpers((_self, container) => {
+      calledWithObject.argsToValuesMap.set(calledWithArgs, container);
+    })
+  );
 }
 
 // src/lib/settled-results.ts
@@ -467,11 +476,16 @@ function installSettledResultsPolyfill(mockFn) {
 
 // src/lib/spy-mark.ts
 var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
-var RESET_CONFIG = /* @__PURE__ */ Symbol.for("vitest-auto-spy.resetConfig");
-var CLEAR_HOOK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.clearHook");
 var DEEP_CHILDREN = /* @__PURE__ */ Symbol.for("vitest-auto-spy.deepChildren");
-function markAsMock(mock) {
-  Object.defineProperty(mock, AUTO_SPY_MARK, { value: true, enumerable: false, configurable: true });
+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) {
@@ -493,29 +507,11 @@ function readDeepChildren(value) {
   }
   return [...children.values()].filter(isMarkedMock);
 }
-function attachConfigReset(spy, reset2) {
-  Object.defineProperty(spy, RESET_CONFIG, { value: reset2, enumerable: false, configurable: true });
-}
 function runConfigReset(mock) {
-  if (!(RESET_CONFIG in mock)) {
-    return;
-  }
-  const reset2 = Reflect.get(mock, RESET_CONFIG);
-  if (typeof reset2 === "function") {
-    reset2();
-  }
-}
-function attachClearHook(spy, clear) {
-  Object.defineProperty(spy, CLEAR_HOOK, { value: clear, enumerable: false, configurable: true });
+  hooksOf(mock)?.reset();
 }
 function runClearHook(mock) {
-  if (!(CLEAR_HOOK in mock)) {
-    return;
-  }
-  const clear = Reflect.get(mock, CLEAR_HOOK);
-  if (typeof clear === "function") {
-    clear();
-  }
+  hooksOf(mock)?.clear();
 }
 
 // src/lib/function-spy.ts
@@ -610,6 +606,68 @@ function ensureCalledWithObject(state, chain) {
   state[chain] = created;
   return created;
 }
+var FunctionSpyInternals = class {
+  constructor(state, valueContainer, host, dispatch, recorder) {
+    this.state = state;
+    this.valueContainer = valueContainer;
+    this.host = host;
+    this.dispatch = dispatch;
+    this.recorder = recorder;
+    this.observable = void 0;
+  }
+  /**
+   * `resetAutoSpy` reverts this spy's configuration; the state lives here, where the host runner's
+   * own reset cannot reach it. Clearing the container in place keeps the reference the mock
+   * implementation closed over.
+   */
+  reset() {
+    const { state, valueContainer } = this;
+    delete state.calledWith;
+    delete state.mustBeCalledWith;
+    valueContainer.value = void 0;
+    delete valueContainer._isRejectedPromise;
+    delete valueContainer._isThrown;
+    delete valueContainer.valuesPerCalls;
+    this.observable?.reset();
+    getMockAdapter().restoreImplementation(this.host, this.dispatch);
+  }
+  /** Empties the polyfilled `settledResults` on `clearAutoSpy` / `resetAutoSpy` (a no-op on Vitest, where the host clears its native array). */
+  clear() {
+    this.recorder.clear();
+  }
+};
+function internalsOf(self, helper) {
+  const mark = typeof self === "function" || typeof self === "object" && self !== null ? Reflect.get(self, AUTO_SPY_MARK) : void 0;
+  if (mark instanceof FunctionSpyInternals) {
+    return mark;
+  }
+  throw detachedHelperError(helper);
+}
+var SPY_HELPERS = /* @__PURE__ */ Object.assign(
+  // The inner call carries its own mark: a pure annotation covers the call it precedes, not its
+  // arguments, and an unmarked argument call is evaluated — and everything it reaches kept.
+  /* @__PURE__ */ promiseHelpers((self, container, helper) => {
+    storePromiseConfig(internalsOf(self, helper).valueContainer, container);
+  }),
+  {
+    failWith(error) {
+      const { valueContainer } = internalsOf(this, "failWith");
+      valueContainer.value = error;
+      valueContainer._isThrown = true;
+      valueContainer._isRejectedPromise = false;
+      valueContainer.valuesPerCalls = [];
+    },
+    calledWith(...calledWithArgs) {
+      return addMethodsToCalledWith(ensureCalledWithObject(internalsOf(this, "calledWith").state, "calledWith"), calledWithArgs);
+    },
+    mustBeCalledWith(...calledWithArgs) {
+      return addMethodsToCalledWith(
+        ensureCalledWithObject(internalsOf(this, "mustBeCalledWith").state, "mustBeCalledWith"),
+        calledWithArgs
+      );
+    }
+  }
+);
 function createFunctionSpy(name, unstubbed) {
   const valueContainer = { value: void 0 };
   const state = { valueContainer };
@@ -621,46 +679,16 @@ function createFunctionSpy(name, unstubbed) {
   const functionSpy = getMockAdapter().createMockFn(dispatch, name);
   const recorder = installSettledResultsPolyfill(functionSpy);
   settledResultsRecorder = recorder;
-  addPromiseHelpersToFunctionSpy(functionSpy, valueContainer);
-  const resetObservableStream = getObservableSupport()?.addToFunctionSpy(functionSpy, valueContainer);
-  const spy = decorate(functionSpy, {
-    // The sync twin of `resolveWith` / `nextWith`, and the reason it is here rather than left to
-    // the runner: Vitest 4.1 grew `mockThrow`, but Bun and `node:test` have nothing like it, and
-    // no runtime has a way to make a *`calledWith` chain* throw — `mockImplementation` replaces the
-    // whole dispatch, which is the opposite of configuring one set of arguments.
-    //
-    // `failWith` and not `throwWith`, which is the name the shape asks for: `throwWith` is already
-    // the observable helper that *errors the stream*, it is attached to every spy at runtime (the
-    // return type that tells the two apart exists only in the types), and whichever is installed
-    // last wins. Sharing the name therefore breaks one of them on every spy in the run — which it
-    // did, loudly, the first time this was written that way.
-    failWith: (error) => {
-      valueContainer.value = error;
-      valueContainer._isThrown = true;
-      valueContainer._isRejectedPromise = false;
-      valueContainer.valuesPerCalls = [];
-    },
-    calledWith: (...calledWithArgs) => addMethodsToCalledWith(ensureCalledWithObject(state, "calledWith"), calledWithArgs),
-    mustBeCalledWith: (...calledWithArgs) => addMethodsToCalledWith(ensureCalledWithObject(state, "mustBeCalledWith"), calledWithArgs)
-  });
+  const internals = new FunctionSpyInternals(state, valueContainer, functionSpy, dispatch, recorder);
+  const spy = decorate(functionSpy, SPY_HELPERS);
+  internals.observable = getObservableSupport()?.addToFunctionSpy(spy, valueContainer);
   getJasmineSupport()?.addToFunctionSpy(spy, {
     name,
     restoreDispatch: () => {
       getMockAdapter().restoreImplementation(functionSpy, dispatch);
     }
   });
-  attachConfigReset(spy, () => {
-    delete state.calledWith;
-    delete state.mustBeCalledWith;
-    valueContainer.value = void 0;
-    delete valueContainer._isRejectedPromise;
-    delete valueContainer._isThrown;
-    delete valueContainer.valuesPerCalls;
-    resetObservableStream?.();
-    getMockAdapter().restoreImplementation(functionSpy, dispatch);
-  });
-  attachClearHook(spy, () => recorder.clear());
-  markAsMock(spy);
+  markAsMock(spy, internals);
   return exposeAsSpy(spy);
 }
 function exposeAsSpy(spy) {

package/dist/bun-angular.js

@@ -1,14 +1,13 @@
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-LIOV4WZK.js';
+import { createSpyForToken } from './chunk-VPRUMHEL.js';
 import './chunk-NQXXUJPS.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-CR5Q3YMQ.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DMOJ4NZH.js';
-import { createSpyFromClass } from './chunk-3OX44LME.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3OX44LME.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-IZO7U34R.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-MMKKLL5J.js';
+import { createSpyFromClass } from './chunk-GEXYXX4P.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GEXYXX4P.js';
 import './chunk-PC3FAZT3.js';
-import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-AQSVZK2R.js';
-export { createFunctionSpy, errorHandler } from './chunk-AQSVZK2R.js';
-import './chunk-J5O72UHX.js';
+export { createFunctionSpy, errorHandler } from './chunk-52DZMI55.js';
+import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-4K5F2NVN.js';
 import '@angular/compiler';
 import { NgModule, provideZonelessChangeDetection, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, ApplicationRef, ɵSIGNAL as _SIGNAL } from '@angular/core';
 import { getTestBed, TestBed } from '@angular/core/testing';

package/dist/bun.js

@@ -1,8 +1,8 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.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-CR5Q3YMQ.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DMOJ4NZH.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3OX44LME.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-IZO7U34R.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-MMKKLL5J.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GEXYXX4P.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-AQSVZK2R.js';
-import './chunk-J5O72UHX.js';
+export { createFunctionSpy, errorHandler } from './chunk-52DZMI55.js';
+import './chunk-4K5F2NVN.js';

package/dist/chunk-4K5F2NVN.js

@@ -0,0 +1,91 @@
+// src/lib/docs-links.ts
+var DOCS = "https://asdalexey.github.io/vitest-auto-spy";
+var DOCS_LINKS = {
+  angular: `${DOCS}/adapters/angular`,
+  // Their own pages rather than anchors on `adapters/angular`: a reader who hits one of these arrived
+  // from a failure, not from reading, and the page they want is the one about that check — not the
+  // one about the adapter that hosts it.
+  angularDiagnostics: `${DOCS}/adapters/angular-diagnostics`,
+  angularOverrides: `${DOCS}/adapters/angular-overrides`,
+  autoMockByType: `${DOCS}/core/auto-mock-by-type`,
+  bunAngular: `${DOCS}/runtimes/bun-angular`,
+  createSpyFromClass: `${DOCS}/core/create-spy-from-class`,
+  constructorSpy: `${DOCS}/utilities/constructor-doubles`,
+  controlHelpers: `${DOCS}/core/control-helpers`,
+  eventLoop: `${DOCS}/utilities/event-loop`,
+  fakeTimers: `${DOCS}/utilities/fake-timers`,
+  installation: `${DOCS}/core/installation`,
+  mediaElement: `${DOCS}/utilities/media-element`,
+  moduleMocks: `${DOCS}/utilities/module-mocks`,
+  observerStubs: `${DOCS}/utilities/observer-stubs`,
+  // The recipe for the one failure no spy library can work around: a binding the bundler already
+  // inlined. Deep-linked to the section rather than the page, because the page's first half is
+  // about the *silent* half of the same problem and the reader arriving here has the loud one.
+  realSeam: `${DOCS}/utilities/module-mocks#provide-a-real-seam`,
+  rxjs: `${DOCS}/runtimes/rxjs`,
+  setup: `${DOCS}/utilities/setup`,
+  // Its own page rather than a section of the factory's: the reader arriving here was thrown at by a
+  // double they configured somewhere else entirely, and the question they have is what counts as
+  // configured — which is the whole page, not a paragraph of another one.
+  strictMode: `${DOCS}/core/strict-mode`,
+  trackInjections: `${DOCS}/utilities/track-injections`
+};
+function withDocs(message, link) {
+  return `${message}
+Docs: ${link}`;
+}
+
+// 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-decoration.ts
+function detachedHelperError(helper) {
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] ${helper} was called off its spy: \`const { ${helper} } = spy.method\` loses the spy it configures. Call it as a method \u2014 spy.method.${helper}(\u2026) \u2014 or bind it first.`,
+      DOCS_LINKS.controlHelpers
+    )
+  );
+}
+function decorate(target, helpers) {
+  return Object.assign(target, helpers);
+}
+
+export { AUTO_SPY_MARK, DEEP_CHILDREN, DOCS_LINKS, decorate, detachedHelperError, hooksOf, isAutoSpyLike, isMarkedMock, markAsMock, readDeepChildren, runClearHook, runConfigReset, withDocs };