vitest-auto-spy 4.0.1 → 4.2.0

package/dist/angular.js

@@ -6,16 +6,390 @@ import { isStandalone, Component, Injector, runInInjectionContext, NO_ERRORS_SCH
 import { By } from '@angular/platform-browser';
 
 // src/lib/use-vitest-adapter.ts
+
+// src/lib/constants.ts
+var SWEEP_SENTINEL = /* @__PURE__ */ Symbol.for("vitest-auto-spy.sweepSentinel");
+
+// src/lib/dispose-symbol.ts
+var NODE_DISPOSE_KEY = "nodejs.dispose";
+function installDisposeSymbol(host) {
+  const existing = Reflect.get(host, "dispose");
+  if (typeof existing === "symbol") {
+    return existing;
+  }
+  const shim = Symbol.for(NODE_DISPOSE_KEY);
+  Object.defineProperty(host, "dispose", { value: shim, enumerable: false, configurable: true, writable: false });
+  return shim;
+}
+var DISPOSE = installDisposeSymbol(Symbol);
+
+// src/lib/spy-probe.ts
+var FAST_SPY_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.fastSpy");
+function isFastSpy(value) {
+  return typeof value === "function" && FAST_SPY_BRAND in value;
+}
+function isThenable(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  return typeof Reflect.get(value, "then") === "function";
+}
+
+// src/lib/fast-spy.ts
+var clearEpoch = 0;
+var resetEpoch = 0;
+function clearAllFastSpies() {
+  clearEpoch += 1;
+}
+function resetAllFastSpies() {
+  clearEpoch += 1;
+  resetEpoch += 1;
+}
+var CONFIG = /* @__PURE__ */ Symbol("vitest-auto-spy.fastSpy.config");
+var STATE = /* @__PURE__ */ Symbol("vitest-auto-spy.fastSpy.state");
+var invocationCallCounter = 1;
+var FastMockStateImpl = class {
+  constructor(owner) {
+    this.owner = owner;
+    this.recordedCalls = [];
+    this.recordedContexts = [];
+    this.recordedInstances = [];
+    this.recordedOrder = [];
+    this.recordedResults = [];
+    this.recordedSettledResults = [];
+  }
+  get calls() {
+    syncEpochs(this.owner);
+    return this.recordedCalls;
+  }
+  set calls(value) {
+    this.recordedCalls = value;
+  }
+  get contexts() {
+    syncEpochs(this.owner);
+    return this.recordedContexts;
+  }
+  set contexts(value) {
+    this.recordedContexts = value;
+  }
+  get instances() {
+    syncEpochs(this.owner);
+    return this.recordedInstances;
+  }
+  set instances(value) {
+    this.recordedInstances = value;
+  }
+  get invocationCallOrder() {
+    syncEpochs(this.owner);
+    return this.recordedOrder;
+  }
+  set invocationCallOrder(value) {
+    this.recordedOrder = value;
+  }
+  get results() {
+    syncEpochs(this.owner);
+    return this.recordedResults;
+  }
+  set results(value) {
+    this.recordedResults = value;
+  }
+  get settledResults() {
+    syncEpochs(this.owner);
+    return this.recordedSettledResults;
+  }
+  set settledResults(value) {
+    this.recordedSettledResults = value;
+  }
+  get lastCall() {
+    const calls = this.calls;
+    return calls[calls.length - 1];
+  }
+  /** Drop everything recorded, keeping the object identity a spec may be holding. */
+  empty() {
+    this.recordedCalls = [];
+    this.recordedContexts = [];
+    this.recordedInstances = [];
+    this.recordedOrder = [];
+    this.recordedResults = [];
+    this.recordedSettledResults = [];
+  }
+};
+function syncEpochs(spy) {
+  const config = spy[CONFIG];
+  if (config.resetSeen !== resetEpoch) {
+    config.resetSeen = resetEpoch;
+    config.implementation = config.original;
+    config.onceImplementations = [];
+  }
+  if (config.clearSeen !== clearEpoch) {
+    config.clearSeen = clearEpoch;
+    spy[STATE]?.empty();
+  }
+}
+function configOf(spy) {
+  syncEpochs(spy);
+  return spy[CONFIG];
+}
+function stateOf(spy) {
+  const existing = spy[STATE];
+  if (existing) {
+    return existing;
+  }
+  const created = new FastMockStateImpl(spy);
+  spy[STATE] = created;
+  return created;
+}
+function throwConstructorError(shorthand) {
+  throw new TypeError(
+    `Cannot use \`${shorthand}\` when called with \`new\`. Use \`mockImplementation\` with a \`class\` keyword instead. See https://vitest.dev/api/mock#class-support for more information.`
+  );
+}
+function self(value) {
+  return value;
+}
+var FAST_SPY_PROTOTYPE = Object.create(Function.prototype);
+function definePrototypeMember(key, value) {
+  Object.defineProperty(FAST_SPY_PROTOTYPE, key, { value, writable: true, configurable: true, enumerable: false });
+}
+definePrototypeMember(FAST_SPY_BRAND, true);
+definePrototypeMember("_isMockFunction", true);
+Object.defineProperty(FAST_SPY_PROTOTYPE, "mock", {
+  get() {
+    const spy = self(this);
+    syncEpochs(spy);
+    return stateOf(spy);
+  },
+  configurable: true,
+  enumerable: true
+});
+definePrototypeMember("getMockImplementation", function getMockImplementation() {
+  const config = configOf(self(this));
+  return config.onceImplementations[0] ?? config.implementation;
+});
+definePrototypeMember("mockImplementation", function mockImplementation(implementation) {
+  configOf(self(this)).implementation = implementation;
+  return this;
+});
+definePrototypeMember("mockImplementationOnce", function mockImplementationOnce(implementation) {
+  configOf(self(this)).onceImplementations.push(implementation);
+  return this;
+});
+definePrototypeMember(
+  "withImplementation",
+  function withImplementation(implementation, callback) {
+    const spy = self(this);
+    const config = configOf(spy);
+    const previousImplementation = config.implementation;
+    const previousOnce = config.onceImplementations;
+    const restore = () => {
+      config.implementation = previousImplementation;
+      config.onceImplementations = previousOnce;
+    };
+    config.implementation = implementation;
+    config.onceImplementations = [];
+    const returned = callback();
+    if (isThenable(returned)) {
+      return returned.then(() => {
+        restore();
+        return spy;
+      });
+    }
+    restore();
+    return spy;
+  }
+);
+definePrototypeMember("mockReturnThis", function mockReturnThis() {
+  configOf(self(this)).implementation = function returnThis() {
+    return this;
+  };
+  return this;
+});
+definePrototypeMember("mockReturnValue", function mockReturnValue(value) {
+  configOf(self(this)).implementation = function returnValue() {
+    if (new.target) {
+      throwConstructorError("mockReturnValue");
+    }
+    return value;
+  };
+  return this;
+});
+definePrototypeMember("mockReturnValueOnce", function mockReturnValueOnce(value) {
+  configOf(self(this)).onceImplementations.push(function returnValueOnce() {
+    if (new.target) {
+      throwConstructorError("mockReturnValueOnce");
+    }
+    return value;
+  });
+  return this;
+});
+definePrototypeMember("mockThrow", function mockThrow(value) {
+  configOf(self(this)).implementation = function throwValue() {
+    throw value;
+  };
+  return this;
+});
+definePrototypeMember("mockThrowOnce", function mockThrowOnce(value) {
+  configOf(self(this)).onceImplementations.push(function throwValueOnce() {
+    throw value;
+  });
+  return this;
+});
+definePrototypeMember("mockResolvedValue", function mockResolvedValue(value) {
+  configOf(self(this)).implementation = function resolvedValue() {
+    if (new.target) {
+      throwConstructorError("mockResolvedValue");
+    }
+    return Promise.resolve(value);
+  };
+  return this;
+});
+definePrototypeMember("mockResolvedValueOnce", function mockResolvedValueOnce(value) {
+  configOf(self(this)).onceImplementations.push(function resolvedValueOnce() {
+    if (new.target) {
+      throwConstructorError("mockResolvedValueOnce");
+    }
+    return Promise.resolve(value);
+  });
+  return this;
+});
+definePrototypeMember("mockRejectedValue", function mockRejectedValue(value) {
+  configOf(self(this)).implementation = function rejectedValue() {
+    if (new.target) {
+      throwConstructorError("mockRejectedValue");
+    }
+    return Promise.reject(value);
+  };
+  return this;
+});
+definePrototypeMember("mockRejectedValueOnce", function mockRejectedValueOnce(value) {
+  configOf(self(this)).onceImplementations.push(function rejectedValueOnce() {
+    if (new.target) {
+      throwConstructorError("mockRejectedValueOnce");
+    }
+    return Promise.reject(value);
+  });
+  return this;
+});
+function clearSpy(spy) {
+  syncEpochs(spy);
+  spy[STATE]?.empty();
+}
+function resetSpy(spy) {
+  const config = configOf(spy);
+  spy[STATE]?.empty();
+  config.implementation = config.original;
+  config.onceImplementations = [];
+}
+definePrototypeMember("mockClear", function mockClear() {
+  clearSpy(self(this));
+  return this;
+});
+definePrototypeMember("mockReset", function mockReset() {
+  resetSpy(self(this));
+  return this;
+});
+definePrototypeMember("mockRestore", function mockRestore() {
+  resetSpy(self(this));
+  return void 0;
+});
+definePrototypeMember("mockName", function mockName(name) {
+  if (typeof name === "string") {
+    self(this)[CONFIG].name = name;
+  }
+  return this;
+});
+definePrototypeMember("getMockName", function getMockName() {
+  return self(this)[CONFIG].name || "vi.fn()";
+});
+definePrototypeMember(DISPOSE, function dispose() {
+  resetSpy(self(this));
+});
+function settleInto(settled, returned) {
+  if (isThenable(returned)) {
+    returned.then(
+      (value) => {
+        settled.type = "fulfilled";
+        settled.value = value;
+      },
+      (reason) => {
+        settled.type = "rejected";
+        settled.value = reason;
+      }
+    );
+    return;
+  }
+  settled.type = "fulfilled";
+  settled.value = returned;
+}
+function invoke(spy, thisArg, args, newTarget) {
+  const config = spy[CONFIG];
+  if (config.clearSeen !== clearEpoch || config.resetSeen !== resetEpoch) {
+    syncEpochs(spy);
+  }
+  const state = spy[STATE] ?? stateOf(spy);
+  const result = { type: "incomplete", value: void 0 };
+  const settled = { type: "incomplete", value: void 0 };
+  const context = newTarget ? void 0 : thisArg;
+  state.recordedCalls.push(args);
+  state.recordedOrder.push(invocationCallCounter++);
+  state.recordedResults.push(result);
+  state.recordedSettledResults.push(settled);
+  state.recordedContexts.push(context);
+  state.recordedInstances.push(context);
+  const implementation = config.onceImplementations.shift() ?? config.implementation;
+  let returned;
+  try {
+    returned = newTarget ? Reflect.construct(implementation ?? Object, args, newTarget) : implementation?.apply(thisArg, args);
+  } catch (error) {
+    result.type = "throw";
+    result.value = error;
+    settled.type = "rejected";
+    settled.value = error;
+    throw error;
+  }
+  result.type = "return";
+  result.value = returned;
+  if (newTarget) {
+    state.recordedContexts[state.recordedContexts.length - 1] = returned;
+    state.recordedInstances[state.recordedInstances.length - 1] = returned;
+  }
+  settleInto(settled, returned);
+  return returned;
+}
+function createFastSpy(implementation, name) {
+  const config = {
+    implementation,
+    onceImplementations: [],
+    name: name ?? "",
+    original: implementation,
+    clearSeen: clearEpoch,
+    resetSeen: resetEpoch
+  };
+  const callable = function Mock(...args) {
+    return invoke(spy, this, args, new.target);
+  };
+  const spy = callable;
+  Object.setPrototypeOf(spy, FAST_SPY_PROTOTYPE);
+  spy[CONFIG] = config;
+  spy[STATE] = void 0;
+  return spy;
+}
 function asVitestMock(mock) {
   return mock;
 }
+var sweepSentinel = vi.fn();
+Object.defineProperty(sweepSentinel, SWEEP_SENTINEL, { value: true, enumerable: false, configurable: true });
+sweepSentinel.mockClear = function clearAllMocksSweep() {
+  clearAllFastSpies();
+  return sweepSentinel;
+};
+sweepSentinel.mockReset = function resetAllMocksSweep() {
+  resetAllFastSpies();
+  return sweepSentinel;
+};
 var vitestMockAdapter = guardAccessorSpies({
   createMockFn(implementation, name) {
-    const mock = implementation ? vi.fn(implementation) : vi.fn();
-    if (name !== void 0) {
-      mock.mockName(name);
-    }
-    return mock;
+    return createFastSpy(implementation, name) ;
   },
   spyOnGetter(target, property) {
     return vi.spyOn(target, property, "get");
@@ -42,19 +416,6 @@ function useVitestAdapter() {
   registerMockAdapter(vitestMockAdapter);
 }
 
-// src/lib/dispose-symbol.ts
-var NODE_DISPOSE_KEY = "nodejs.dispose";
-function installDisposeSymbol(host) {
-  const existing = Reflect.get(host, "dispose");
-  if (typeof existing === "symbol") {
-    return existing;
-  }
-  const shim = Symbol.for(NODE_DISPOSE_KEY);
-  Object.defineProperty(host, "dispose", { value: shim, enumerable: false, configurable: true, writable: false });
-  return shim;
-}
-var DISPOSE = installDisposeSymbol(Symbol);
-
 // src/lib/docs-links.ts
 var DOCS = "https://asdalexey.github.io/vitest-auto-spy";
 var DOCS_LINKS = {
@@ -169,6 +530,17 @@ function serializeValue(value) {
 }
 
 // src/lib/args-map.ts
+function isSinglePrimitiveArgs(args) {
+  if (args.length !== 1) {
+    return false;
+  }
+  const [argument] = args;
+  const kind = typeof argument;
+  if (kind === "object" || kind === "function" || kind === "symbol") {
+    return argument === null;
+  }
+  return !Object.is(argument, -0);
+}
 function isAsymmetricMatcher(value) {
   return typeof value === "object" && value !== null && "asymmetricMatch" in value && typeof value.asymmetricMatch === "function";
 }
@@ -203,6 +575,21 @@ var ArgsMap = class {
   // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
   // build a key that provably cannot match, and throws it away one line later.
   #arities = /* @__PURE__ */ new Set();
+  /**
+   * The configs of exactly one primitive argument, keyed by the argument itself.
+   *
+   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+   * do on the value with no allocation at all. The configs live in both maps: the string map still
+   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+   * changes.
+   *
+   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+   */
+  #exactSinglePrimitive = /* @__PURE__ */ new Map();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
       this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
@@ -210,6 +597,9 @@ var ArgsMap = class {
     }
     if (Array.isArray(key)) {
       this.#arities.add(key.length);
+      if (isSinglePrimitiveArgs(key)) {
+        this.#exactSinglePrimitive.set(key[0], value);
+      }
     }
     this.#map[this.#serialize(key)] = value;
   }
@@ -217,6 +607,10 @@ var ArgsMap = class {
     if (Array.isArray(key) && !this.#arities.has(key.length)) {
       return this.#findByMatcher(key);
     }
+    if (Array.isArray(key) && isSinglePrimitiveArgs(key)) {
+      const hit = this.#exactSinglePrimitive.get(key[0]);
+      return hit === void 0 ? this.#findByMatcher(key) : hit;
+    }
     const serialized = this.#serialize(key);
     if (serialized in this.#map) {
       return this.#map[serialized];
@@ -431,16 +825,12 @@ function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
 
 // src/lib/settled-results.ts
 var NATIVE_RECORDER = {
-  record: (returned) => returned,
   clear: () => void 0
 };
-function isThenable(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return false;
-  }
-  return typeof Reflect.get(value, "then") === "function";
-}
 function installSettledResultsPolyfill(mockFn) {
+  if (isFastSpy(mockFn)) {
+    return NATIVE_RECORDER;
+  }
   const state = Reflect.get(mockFn, "mock");
   if (typeof state !== "object" || state === null || "settledResults" in state) {
     return NATIVE_RECORDER;
@@ -636,8 +1026,8 @@ var FunctionSpyInternals = class {
     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;
+function internalsOf(self2, helper) {
+  const mark = typeof self2 === "function" || typeof self2 === "object" && self2 !== null ? Reflect.get(self2, AUTO_SPY_MARK) : void 0;
   if (mark instanceof FunctionSpyInternals) {
     return mark;
   }
@@ -646,8 +1036,8 @@ function internalsOf(self, 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);
+  /* @__PURE__ */ promiseHelpers((self2, container, helper) => {
+    storePromiseConfig(internalsOf(self2, helper).valueContainer, container);
   }),
   {
     failWith(error) {
@@ -674,11 +1064,11 @@ function createFunctionSpy(name, unstubbed) {
   let settledResultsRecorder = void 0;
   const dispatch = (...actualArgs) => {
     const returned = returnTheCorrectFakeValue(state, actualArgs, name, unstubbed);
-    return settledResultsRecorder ? settledResultsRecorder.record(returned) : returned;
+    return settledResultsRecorder ? settledResultsRecorder(returned) : returned;
   };
   const functionSpy = getMockAdapter().createMockFn(dispatch, name);
   const recorder = installSettledResultsPolyfill(functionSpy);
-  settledResultsRecorder = recorder;
+  settledResultsRecorder = recorder.record;
   const internals = new FunctionSpyInternals(state, valueContainer, functionSpy, dispatch, recorder);
   const spy = decorate(functionSpy, SPY_HELPERS);
   internals.observable = getObservableSupport()?.addToFunctionSpy(spy, valueContainer);

package/dist/bun-angular.js

@@ -1,14 +1,14 @@
 import { flushEffects } from './chunk-5BPM3BLI.js';
 export { flushEffects, stable } from './chunk-5BPM3BLI.js';
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-6EGUFU73.js';
+import { createSpyForToken } from './chunk-KEKKEIRG.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-M3XZL5NF.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5URFSYDT.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DSIYS6Y5.js';
-import { createSpyFromClass } from './chunk-N4PT3JYE.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-N4PT3JYE.js';
+import { createSpyFromClass } from './chunk-4KCYFAJX.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-4KCYFAJX.js';
+export { createFunctionSpy, errorHandler } from './chunk-4KK3ES4P.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-3QJUFL2N.js';
 import { isAutoSpyLike } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';
 import '@angular/compiler';

package/dist/bun.js

@@ -1,9 +1,9 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-M3XZL5NF.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5URFSYDT.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DSIYS6Y5.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-N4PT3JYE.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-4KCYFAJX.js';
+export { createFunctionSpy, errorHandler } from './chunk-4KK3ES4P.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-3QJUFL2N.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/{chunk-XJ3UMJN3.js → chunk-2ZG27FVL.js}

@@ -1,4 +1,4 @@
-import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
+import { vitestMockAdapter } from './chunk-WQZ2RKS7.js';
 import { registerMockAdapter } from './shared-state.js';
 
 function useVitestAdapter() {

package/dist/{chunk-N4PT3JYE.js → chunk-4KCYFAJX.js}

@@ -1,5 +1,5 @@
+import { resolveUnstubbedGuard, createFunctionSpy } from './chunk-4KK3ES4P.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { resolveUnstubbedGuard, createFunctionSpy } from './chunk-3QJUFL2N.js';
 import { runClearHook, runConfigReset, AUTO_SPY_MARK, isMarkedMock, readDeepChildren, markAsMock } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';
 import { getMockAdapter, requireObservableSupport, getJasmineSupport } from './shared-state.js';

package/dist/{chunk-3QJUFL2N.js → chunk-4KK3ES4P.js}

@@ -148,6 +148,17 @@ Actual: ${actualCall(functionName, actualArgs)}`;
 };
 
 // src/lib/args-map.ts
+function isSinglePrimitiveArgs(args) {
+  if (args.length !== 1) {
+    return false;
+  }
+  const [argument] = args;
+  const kind = typeof argument;
+  if (kind === "object" || kind === "function" || kind === "symbol") {
+    return argument === null;
+  }
+  return !Object.is(argument, -0);
+}
 function isAsymmetricMatcher(value) {
   return typeof value === "object" && value !== null && "asymmetricMatch" in value && typeof value.asymmetricMatch === "function";
 }
@@ -182,6 +193,21 @@ var ArgsMap = class {
   // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
   // build a key that provably cannot match, and throws it away one line later.
   #arities = /* @__PURE__ */ new Set();
+  /**
+   * The configs of exactly one primitive argument, keyed by the argument itself.
+   *
+   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+   * do on the value with no allocation at all. The configs live in both maps: the string map still
+   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+   * changes.
+   *
+   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+   */
+  #exactSinglePrimitive = /* @__PURE__ */ new Map();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
       this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
@@ -189,6 +215,9 @@ var ArgsMap = class {
     }
     if (Array.isArray(key)) {
       this.#arities.add(key.length);
+      if (isSinglePrimitiveArgs(key)) {
+        this.#exactSinglePrimitive.set(key[0], value);
+      }
     }
     this.#map[this.#serialize(key)] = value;
   }
@@ -196,6 +225,10 @@ var ArgsMap = class {
     if (Array.isArray(key) && !this.#arities.has(key.length)) {
       return this.#findByMatcher(key);
     }
+    if (Array.isArray(key) && isSinglePrimitiveArgs(key)) {
+      const hit = this.#exactSinglePrimitive.get(key[0]);
+      return hit === void 0 ? this.#findByMatcher(key) : hit;
+    }
     const serialized = this.#serialize(key);
     if (serialized in this.#map) {
       return this.#map[serialized];
@@ -336,18 +369,26 @@ function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
   );
 }
 
-// src/lib/settled-results.ts
-var NATIVE_RECORDER = {
-  record: (returned) => returned,
-  clear: () => void 0
-};
+// src/lib/spy-probe.ts
+var FAST_SPY_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.fastSpy");
+function isFastSpy(value) {
+  return typeof value === "function" && FAST_SPY_BRAND in value;
+}
 function isThenable(value) {
   if (typeof value !== "object" && typeof value !== "function" || value === null) {
     return false;
   }
   return typeof Reflect.get(value, "then") === "function";
 }
+
+// src/lib/settled-results.ts
+var NATIVE_RECORDER = {
+  clear: () => void 0
+};
 function installSettledResultsPolyfill(mockFn) {
+  if (isFastSpy(mockFn)) {
+    return NATIVE_RECORDER;
+  }
   const state = Reflect.get(mockFn, "mock");
   if (typeof state !== "object" || state === null || "settledResults" in state) {
     return NATIVE_RECORDER;
@@ -544,11 +585,11 @@ function createFunctionSpy(name, unstubbed) {
   let settledResultsRecorder = void 0;
   const dispatch = (...actualArgs) => {
     const returned = returnTheCorrectFakeValue(state, actualArgs, name, unstubbed);
-    return settledResultsRecorder ? settledResultsRecorder.record(returned) : returned;
+    return settledResultsRecorder ? settledResultsRecorder(returned) : returned;
   };
   const functionSpy = getMockAdapter().createMockFn(dispatch, name);
   const recorder = installSettledResultsPolyfill(functionSpy);
-  settledResultsRecorder = recorder;
+  settledResultsRecorder = recorder.record;
   const internals = new FunctionSpyInternals(state, valueContainer, functionSpy, dispatch, recorder);
   const spy = decorate(functionSpy, SPY_HELPERS);
   internals.observable = getObservableSupport()?.addToFunctionSpy(spy, valueContainer);
@@ -565,4 +606,4 @@ function exposeAsSpy(spy) {
   return spy;
 }
 
-export { createFunctionSpy, defineHelper, errorHandler, resolveUnstubbedGuard, serializeValue, setDefaultStrictMode };
+export { FAST_SPY_BRAND, createFunctionSpy, defineHelper, errorHandler, isThenable, resolveUnstubbedGuard, serializeValue, setDefaultStrictMode };