vitest-auto-spy 4.2.0 → 4.3.0

package/dist/node.cjs

@@ -193,6 +193,18 @@ function spyOnAccessorByRedefine(createMockFn, target, property, type) {
 function asNodeMock(mockFn) {
   return mockFn;
 }
+function nameImplementation(implementation, name) {
+  if (name === void 0) {
+    return implementation;
+  }
+  const named = {
+    // eslint-disable-next-line object-shorthand -- a concise method is not constructable, and `mockConstructor` has the code under test call `new` on this; a function expression is, and is still named by its computed key.
+    [name]: function(...args) {
+      return implementation.apply(this, args);
+    }
+  };
+  return named[name];
+}
 function nameNodeMock(mockFn, name) {
   if (name !== void 0) {
     Object.defineProperty(mockFn, "displayName", { value: name, configurable: true });
@@ -202,7 +214,7 @@ function nameNodeMock(mockFn, name) {
 function createNodeMockAdapter(nodeTest) {
   return guardAccessorSpies(
     createRedefineMockAdapter({
-      createMockFn: (implementation, name) => nameNodeMock(nodeTest.fn(implementation ?? (() => void 0)), name),
+      createMockFn: (implementation, name) => nameNodeMock(nodeTest.fn(nameImplementation(implementation ?? (() => void 0), name)), name),
       getCalls: (mockFn) => asNodeMock(mockFn).mock.calls.map((call) => call.arguments),
       reset: (mockFn) => asNodeMock(mockFn).mock.resetCalls(),
       // `node:test` mocks reset call history via `resetCalls()`; there is no
@@ -567,6 +579,28 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /**
+   * Every configured argument list as a {@link ConfiguredEntry} — the same lists {@link configured}
+   * returns, each carrying its own position and its own predicate.
+   *
+   * The order is the order a lookup consults them (exact configs first, then the asymmetric ones in
+   * registration order), so the first entry whose `matches` holds is the config `get` would have
+   * answered from. That is what lets a reader be told "call 3 hit config 2" instead of a list of
+   * configs and a list of calls with nothing joining them.
+   */
+  configuredEntries() {
+    const exact = Object.keys(this.#map).map((key, position) => ({
+      index: position + 1,
+      args: key,
+      matches: (actualArgs) => this.#serialize(actualArgs) === key
+    }));
+    const asymmetric = this.#matcherConfigs.map((config, position) => ({
+      index: exact.length + position + 1,
+      args: `[${config.described.join(",")}]`,
+      matches: (actualArgs) => this.#argsMatch(config, actualArgs)
+    }));
+    return [...exact, ...asymmetric];
+  }
   /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
   #buildMatcherConfig(key, value) {
     const serialized = [];
@@ -1351,6 +1385,17 @@ function walkOwnPrototypes(prototype, visit) {
     current = parent;
   }
 }
+function getCallableMemberNames(target) {
+  const names = /* @__PURE__ */ new Set();
+  walkOwnPrototypes(target, (obj) => {
+    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(obj))) {
+      if (name !== "constructor" && typeof descriptor.value === "function") {
+        names.add(name);
+      }
+    }
+  });
+  return [...names];
+}
 var methodNamesCache = /* @__PURE__ */ new WeakMap();
 function getAllMethodNames(prototype) {
   const cached = methodNamesCache.get(prototype);
@@ -1408,7 +1453,12 @@ function resolveAccessors(prototype, config) {
   };
 }
 function resolveMethodNames(ObjectClass, config) {
-  const base = config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getAllMethodNames(ObjectClass.prototype);
+  return mergeMethodNames(
+    config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getAllMethodNames(ObjectClass.prototype),
+    config
+  );
+}
+function mergeMethodNames(base, config) {
   if (config.methodsToSpyOn.length === 0 && config.instanceMethodsToSpyOn.length === 0) {
     return base;
   }
@@ -1447,7 +1497,7 @@ function warnOnAccessorNamingAMethod(ObjectClass, config) {
 function isCallable2(value) {
   return typeof value === "function";
 }
-function applyReturns(autoSpy, ObjectClass, returns) {
+function applyReturns(autoSpy, factory, returns) {
   const entries = Object.entries(returns);
   if (entries.length === 0) {
     return;
@@ -1458,7 +1508,7 @@ function applyReturns(autoSpy, ObjectClass, returns) {
     if (!isCallable2(spy)) {
       console.warn(
         withDocs(
-          `[vitest-auto-spy] createSpyFromClass(${ObjectClass.name}): returns names '${name}', which is not a spied method of the spy. Check the spelling, and check that a restricting onlyMethodsToSpyOn list did not leave it out \u2014 a value configured for a method that is not there is silently never returned.`,
+          `[vitest-auto-spy] ${factory}: returns names '${name}', which is not a spied method of the spy. Check the spelling, and check that a restricting onlyMethodsToSpyOn list did not leave it out \u2014 a value configured for a method that is not there is silently never returned.`,
           DOCS_LINKS.createSpyFromClass
         )
       );
@@ -1510,7 +1560,7 @@ function resolveConfiguration(methodsToSpyOnOrConfig) {
 function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
   const config = resolveConfiguration(methodsToSpyOnOrConfig);
   const autoSpy = assembleSpy(ObjectClass, config);
-  applyReturns(autoSpy, ObjectClass, config.returns);
+  applyReturns(autoSpy, `createSpyFromClass(${ObjectClass.name})`, config.returns);
   applyOverrides(autoSpy, config.overrides);
   return autoSpy;
 }
@@ -1557,6 +1607,155 @@ function hasNothingToRead(ObjectClass, accessors, config) {
   config.onlyMethodsToSpyOn.length === 0;
 }
 
+// src/lib/prop-mock.ts
+function getPatchedProps() {
+  return globalThis.__vitestAutoSpyPatchedProps__ ??= [];
+}
+function rememberProp(object, property, descriptor) {
+  const patch = {
+    // The helpers only ever patch objects; the cast bridges the generic `T` of the public API.
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- `T` is unconstrained on the public signatures, but every caller passes an object (a service instance, a class prototype or a global).
+    object,
+    property,
+    descriptor,
+    undone: false
+  };
+  getPatchedProps().push(patch);
+  return () => {
+    if (patch.undone) {
+      return;
+    }
+    patch.undone = true;
+    restorePatch(patch);
+  };
+}
+function applyPatch(object, property, descriptor) {
+  const previous = Object.getOwnPropertyDescriptor(object, property);
+  try {
+    Object.defineProperty(object, property, descriptor);
+  } catch (error) {
+    if (isCannotRedefine(error)) {
+      throw redefineFailure(
+        `Cannot mock the property '${String(property)}': it is not configurable, so it cannot be redefined.`,
+        Object(object),
+        error
+      );
+    }
+    throw error;
+  }
+  return rememberProp(object, property, previous);
+}
+function restorePatch({ object, property, descriptor }) {
+  if (descriptor) {
+    Object.defineProperty(object, property, descriptor);
+    return;
+  }
+  Reflect.deleteProperty(object, property);
+}
+function describeRestoreFailures(failures) {
+  return withDocs(
+    `[vitest-auto-spy] restoreMockedProps() could not put ${failures.length} of the patched properties back:
+${failures.join("\n")}
+A property that was redefined as non-configurable can never be restored \u2014 \`Object.defineProperty\` defaults \`configurable\` to \`false\`, so a plain redefinition of an already-mocked property seals it for the rest of the worker. \`setupAutoSpy({ guardGlobals: 'throw' })\` names the test that does it. Every other patch of this sweep was restored, and the journal is empty either way \u2014 nothing here is replayed against a descriptor that has since moved on.`,
+    DOCS_LINKS.setup
+  );
+}
+function countMockedProps() {
+  return getPatchedProps().filter((patch) => !patch.undone).length;
+}
+function restoreMockedProps() {
+  const patchedProps = getPatchedProps();
+  const pending = [...patchedProps].reverse();
+  const failures = [];
+  patchedProps.length = 0;
+  for (const patch of pending) {
+    if (patch.undone) {
+      continue;
+    }
+    patch.undone = true;
+    try {
+      restorePatch(patch);
+    } catch (error) {
+      failures.push(`  - ${String(patch.property)}: ${String(error)}`);
+    }
+  }
+  if (failures.length > 0) {
+    throw new Error(describeRestoreFailures(failures));
+  }
+}
+function mockReadonlyProp(object, property, value) {
+  return applyPatch(object, property, { get: () => value, configurable: true });
+}
+function mockReadonlyPropGetter(object, property, getter) {
+  return applyPatch(object, property, { get: getter, configurable: true });
+}
+function mockValueProp(object, property, value) {
+  return applyPatch(object, property, { value, writable: true, configurable: true });
+}
+function mockAccessorsProp(object, property, accessors) {
+  const adapter = getMockAdapter();
+  return applyPatch(object, property, {
+    get: adapter.createMockFn(accessors?.get),
+    set: adapter.createMockFn(accessors?.set),
+    configurable: true
+  });
+}
+
+// src/lib/create-spy-from-instance.ts
+var installedSpies = /* @__PURE__ */ new WeakMap();
+function constructorName(instance) {
+  const constructor = Reflect.get(instance, "constructor");
+  return typeof constructor === "function" ? constructor.name : void 0;
+}
+function installMember(instance, name, value, restores) {
+  restores.push(mockValueProp(instance, name, value));
+  Object.defineProperty(instance, name, { enumerable: true });
+}
+function installAccessorSpies(instance, config, restores) {
+  const { getters, setters } = resolveAccessors(instance, config);
+  [.../* @__PURE__ */ new Set([...getters, ...setters])].forEach((name) => restores.push(mockAccessorsProp(instance, name)));
+  restores.push(mockValueProp(instance, "accessorSpies", void 0));
+  createAccessorsSpies(instance, getters, setters);
+}
+function disposeSpiedInstance() {
+  restoreSpiedInstance(this);
+}
+function restoreSpiedInstance(instance) {
+  const restores = installedSpies.get(instance);
+  if (!restores) {
+    return;
+  }
+  installedSpies.delete(instance);
+  [...restores].reverse().forEach((restore) => restore());
+}
+function createSpyFromInstance(instance, methodsToSpyOnOrConfig) {
+  if (!Object.isExtensible(instance)) {
+    throw redefineFailure(
+      "Cannot spy on this instance in place: it is not extensible, so its members cannot be replaced.",
+      instance,
+      void 0
+    );
+  }
+  const config = resolveConfiguration(methodsToSpyOnOrConfig);
+  const className = constructorName(instance);
+  const unstubbed = resolveUnstubbedGuard(className, config);
+  const restores = installedSpies.get(instance) ?? [];
+  installedSpies.set(instance, restores);
+  const methodNames = mergeMethodNames(
+    config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getCallableMemberNames(instance),
+    config
+  );
+  methodNames.forEach((name) => installMember(instance, name, createFunctionSpy(name, unstubbed), restores));
+  config.observablePropsToSpyOn.forEach((name) => installMember(instance, name, requireObservableSupport().createPropSpy(), restores));
+  installAccessorSpies(instance, config, restores);
+  applyReturns(instance, `createSpyFromInstance(${className ?? "object"})`, config.returns);
+  for (const key of Reflect.ownKeys(config.overrides)) {
+    installMember(instance, key, Reflect.get(config.overrides, key), restores);
+  }
+  restores.push(mockValueProp(instance, DISPOSE, disposeSpiedInstance));
+  return instance;
+}
+
 // src/lib/create-mock.ts
 function createMock(partial) {
   return partial ?? {};
@@ -1752,98 +1951,53 @@ function captureArg() {
   return new Captor();
 }
 
-// src/lib/prop-mock.ts
-function getPatchedProps() {
-  return globalThis.__vitestAutoSpyPatchedProps__ ??= [];
-}
-function rememberProp(object, property, descriptor) {
-  const patch = {
-    // The helpers only ever patch objects; the cast bridges the generic `T` of the public API.
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- `T` is unconstrained on the public signatures, but every caller passes an object (a service instance, a class prototype or a global).
-    object,
-    property,
-    descriptor,
-    undone: false
-  };
-  getPatchedProps().push(patch);
-  return () => {
-    if (patch.undone) {
-      return;
-    }
-    patch.undone = true;
-    restorePatch(patch);
-  };
+// src/lib/emission-timeout.ts
+var defaultTimeoutMs = 1e3;
+function setEmissionTimeout(milliseconds) {
+  defaultTimeoutMs = milliseconds;
 }
-function applyPatch(object, property, descriptor) {
-  const previous = Object.getOwnPropertyDescriptor(object, property);
-  try {
-    Object.defineProperty(object, property, descriptor);
-  } catch (error) {
-    if (isCannotRedefine(error)) {
-      throw redefineFailure(
-        `Cannot mock the property '${String(property)}': it is not configurable, so it cannot be redefined.`,
-        Object(object),
-        error
-      );
-    }
-    throw error;
-  }
-  return rememberProp(object, property, previous);
+function emissionTimeout() {
+  return defaultTimeoutMs;
 }
-function restorePatch({ object, property, descriptor }) {
-  if (descriptor) {
-    Object.defineProperty(object, property, descriptor);
-    return;
-  }
-  Reflect.deleteProperty(object, property);
-}
-function describeRestoreFailures(failures) {
-  return withDocs(
-    `[vitest-auto-spy] restoreMockedProps() could not put ${failures.length} of the patched properties back:
-${failures.join("\n")}
-A property that was redefined as non-configurable can never be restored \u2014 \`Object.defineProperty\` defaults \`configurable\` to \`false\`, so a plain redefinition of an already-mocked property seals it for the rest of the worker. \`setupAutoSpy({ guardGlobals: 'throw' })\` names the test that does it. Every other patch of this sweep was restored, and the journal is empty either way \u2014 nothing here is replayed against a descriptor that has since moved on.`,
-    DOCS_LINKS.setup
-  );
+
+// src/lib/error-anchor.ts
+var OWN_FAILURE = /* @__PURE__ */ Symbol("vitest-auto-spy.own-failure");
+function ownFailure(message, options) {
+  const error = new Error(message, options);
+  Object.defineProperty(error, OWN_FAILURE, { value: true });
+  return error;
 }
-function countMockedProps() {
-  return getPatchedProps().filter((patch) => !patch.undone).length;
+function anchorOf(stack, boundaryName) {
+  const frames = framesAfter(frameLines(stack), boundaryName);
+  return (error) => anchor(frames, error);
 }
-function restoreMockedProps() {
-  const patchedProps = getPatchedProps();
-  const pending = [...patchedProps].reverse();
-  const failures = [];
-  patchedProps.length = 0;
-  for (const patch of pending) {
-    if (patch.undone) {
-      continue;
-    }
-    patch.undone = true;
-    try {
-      restorePatch(patch);
-    } catch (error) {
-      failures.push(`  - ${String(patch.property)}: ${String(error)}`);
-    }
+function captureAnchor(boundary, host2 = Error) {
+  const holder = new Error();
+  const capture = host2.captureStackTrace;
+  if (capture) {
+    capture(holder, boundary);
+    return anchorOf(holder.stack, "");
   }
-  if (failures.length > 0) {
-    throw new Error(describeRestoreFailures(failures));
+  return anchorOf(holder.stack, boundary.name);
+}
+function anchor(frames, error) {
+  if (frames.length === 0 || Reflect.get(error, OWN_FAILURE) !== true) {
+    return error;
   }
+  error.stack = [`${error.name}: ${error.message}`, ...frames].join("\n");
+  return error;
 }
-function mockReadonlyProp(object, property, value) {
-  return applyPatch(object, property, { get: () => value, configurable: true });
+function frameLines(stack) {
+  const lines = String(stack).split("\n");
+  const first = lines.findIndex(isFrame);
+  return first < 0 ? [] : lines.slice(first);
 }
-function mockReadonlyPropGetter(object, property, getter) {
-  return applyPatch(object, property, { get: getter, configurable: true });
+function isFrame(line) {
+  return /^\s*at\s/.test(line) || /^\S*@/.test(line);
 }
-function mockValueProp(object, property, value) {
-  return applyPatch(object, property, { value, writable: true, configurable: true });
-}
-function mockAccessorsProp(object, property, accessors) {
-  const adapter = getMockAdapter();
-  return applyPatch(object, property, {
-    get: adapter.createMockFn(accessors?.get),
-    set: adapter.createMockFn(accessors?.set),
-    configurable: true
-  });
+function framesAfter(frames, boundaryName) {
+  const boundary = boundaryName === "" ? -1 : frames.findIndex((frame) => frame.includes(boundaryName));
+  return boundary < 0 ? frames : frames.slice(boundary + 1);
 }
 
 // src/lib/expect-emission.ts
@@ -1860,10 +2014,6 @@ function asHybridObserver(observer) {
   const listener = (value) => observer.next(value);
   return Object.assign(listener, observer);
 }
-var defaultTimeoutMs = 1e3;
-function setEmissionTimeout(milliseconds) {
-  defaultTimeoutMs = milliseconds;
-}
 var setTimer = globalThis.setTimeout.bind(globalThis);
 var clearTimer = globalThis.clearTimeout.bind(globalThis);
 function describeSource(options) {
@@ -1886,7 +2036,7 @@ function subscribeAndCollect(source$, options, settle, handlers) {
     clearTimer(timer);
     subscription?.unsubscribe();
   };
-  const timeout = options?.timeout ?? defaultTimeoutMs;
+  const timeout = options?.timeout ?? emissionTimeout();
   const timer = timeout > 0 ? setTimer(() => {
     stop();
     settle.reject(handlers.onTimeout(values, options, timeout));
@@ -1916,39 +2066,43 @@ function subscribeAndCollect(source$, options, settle, handlers) {
   }
   return { values, stop };
 }
+function anchoredRejecter(reject, anchor2) {
+  return (error) => reject(anchor2(error));
+}
 function timeoutError(values, options, waited) {
-  return new Error(
+  return ownFailure(
     `${describeSource(options)} did not emit within ${waited} ms (${values.length} emission(s) received). Either the stream never fired \u2014 check the trigger and any provider spy feeding it \u2014 or it is slower than the timeout; raise it with \`{ timeout: \u2026 }\`. This wait is real time even under fake timers, on purpose: a virtual watchdog would race the timers your spec advances. Lower it with \`setEmissionTimeout(100)\` in the setup file rather than disabling it with \`{ timeout: 0 }\`, which leaves the next silent stream with no message at all.`
   );
 }
 function rejectAsSourceError(error, options, settle) {
-  settle.reject(new Error(`${describeSource(options)} errored instead of emitting: ${String(error)}`, { cause: error }));
+  settle.reject(ownFailure(`${describeSource(options)} errored instead of emitting: ${String(error)}`, { cause: error }));
 }
 function completedError(values, expected, options) {
-  return new Error(
+  return ownFailure(
     `${describeSource(options)} completed after ${values.length} emission(s), expected ${describeExpectation(expected, options)}. A completed-but-empty stream is the usual sign that the value was produced before the subscription.`
   );
 }
 function expectEmission(source$, options) {
-  return collectEmissions(source$, 1, options).then((values) => firstOf(values));
+  return collectEmissions(source$, 1, options, captureAnchor(expectEmission)).then((values) => firstOf(values));
 }
 function firstOf(values) {
   return values[0];
 }
 function expectEmissions(source$, count, options) {
-  return collectEmissions(source$, count, options);
+  return collectEmissions(source$, count, options, captureAnchor(expectEmissions));
 }
-function collectEmissions(source$, count, options) {
+function collectEmissions(source$, count, options, anchor2) {
   return new Promise((resolve, reject) => {
+    const fail = anchoredRejecter(reject, anchor2);
     subscribeAndCollect(
       source$,
       options,
       // Resolved with everything that arrived, then narrowed to the accepted ones: the collector's
       // job is to record, and `skip` / `until` decide what the caller is handed.
-      { resolve: (values) => resolve(accepted(values, options).slice(0, count)), reject },
+      { resolve: (values) => resolve(accepted(values, options).slice(0, count)), reject: fail },
       {
         isDone: (values) => accepted(values, options).length >= count,
-        onComplete: (values) => reject(completedError(values, count, options)),
+        onComplete: (values) => fail(completedError(values, count, options)),
         onTimeout: timeoutError,
         onError: rejectAsSourceError
       }
@@ -1957,14 +2111,16 @@ function collectEmissions(source$, count, options) {
 }
 function expectNoEmission(source$, options) {
   const quietFor = options?.timeout ?? 0;
+  const anchor2 = captureAnchor(expectNoEmission);
   let quietWindow = void 0;
   return new Promise((resolve, reject) => {
+    const fail = anchoredRejecter(reject, anchor2);
     const collector = subscribeAndCollect(
       source$,
       { ...options, timeout: 0 },
       {
-        resolve: (emitted) => reject(unexpectedEmissionError(accepted(emitted, options), options)),
-        reject
+        resolve: (emitted) => fail(unexpectedEmissionError(accepted(emitted, options), options)),
+        reject: fail
       },
       {
         isDone: (values) => accepted(values, options).length > 0,
@@ -1984,11 +2140,12 @@ function expectNoEmission(source$, options) {
   });
 }
 function expectCompletion(source$, options) {
+  const anchor2 = captureAnchor(expectCompletion);
   return new Promise((resolve, reject) => {
     subscribeAndCollect(
       source$,
       options,
-      { resolve, reject },
+      { resolve, reject: anchoredRejecter(reject, anchor2) },
       {
         // Emissions are collected for the failure message, but only completion settles this.
         isDone: staysOpen,
@@ -2003,23 +2160,25 @@ function staysOpen() {
   return false;
 }
 function notCompletedError(values, options, waited) {
-  return new Error(
+  return ownFailure(
     `${describeSource(options)} did not complete within ${waited} ms (${values.length} emission(s) received). A stream that keeps running usually means the completing operator never ran \u2014 check \`take\`, \`first\`, \`takeUntil\`, or a Subject nobody calls \`complete()\` on. The wait is real time even under fake timers; raise it with \`{ timeout: \u2026 }\`, or lower the suite default with \`setEmissionTimeout(\u2026)\`.`
   );
 }
 function rejectAsNotCompleted(error, options, settle) {
-  settle.reject(new Error(`${describeSource(options)} errored instead of completing: ${String(error)}`, { cause: error }));
+  settle.reject(ownFailure(`${describeSource(options)} errored instead of completing: ${String(error)}`, { cause: error }));
 }
 function expectError(source$, options) {
+  const anchor2 = captureAnchor(expectError);
   return new Promise((resolve, reject) => {
+    const fail = anchoredRejecter(reject, anchor2);
     subscribeAndCollect(
       source$,
       options,
-      { resolve, reject },
+      { resolve, reject: fail },
       {
         // Only `error` settles this one: an emission is not the answer, and neither is completion.
         isDone: staysOpen,
-        onComplete: (values) => reject(completedWithoutErrorError(values, options)),
+        onComplete: (values) => fail(completedWithoutErrorError(values, options)),
         onTimeout: notErroredError,
         onError: resolveWithError
       }
@@ -2027,12 +2186,12 @@ function expectError(source$, options) {
   }).then((values) => firstOf(values));
 }
 function completedWithoutErrorError(values, options) {
-  return new Error(
+  return ownFailure(
     `${describeSource(options)} completed after ${values.length} emission(s) without erroring, but an error was expected. Check that the failure path is the one the spec set up \u2014 a spy configured with \`resolveWith\`/\`nextWith\` rather than \`rejectWith\`/\`throwWith\` produces exactly this.`
   );
 }
 function notErroredError(values, options, waited) {
-  return new Error(
+  return ownFailure(
     `${describeSource(options)} did not error within ${waited} ms (${values.length} emission(s) received). The stream is still running: nothing failed, and nothing completed either.`
   );
 }
@@ -2040,7 +2199,7 @@ function resolveWithError(error, _options, settle) {
   settle.resolve([error]);
 }
 function unexpectedEmissionError(values, options) {
-  return new Error(`${describeSource(options)} emitted ${serializeValue(values[0])} but was expected to stay silent.`);
+  return ownFailure(`${describeSource(options)} emitted ${serializeValue(values[0])} but was expected to stay silent.`);
 }
 
 // src/lib/spy-typing.ts
@@ -2290,6 +2449,7 @@ exports.createFunctionSpy = createFunctionSpy;
 exports.createMock = createMock;
 exports.createSpyClass = createSpyClass;
 exports.createSpyFromClass = createSpyFromClass;
+exports.createSpyFromInstance = createSpyFromInstance;
 exports.describeDuplicateCopies = describeDuplicateCopies;
 exports.errorHandler = errorHandler;
 exports.expectCompletion = expectCompletion;
@@ -2311,6 +2471,7 @@ exports.narrow = narrow;
 exports.pruneNodeMocks = pruneNodeMocks;
 exports.resetAutoSpy = resetAutoSpy;
 exports.restoreMockedProps = restoreMockedProps;
+exports.restoreSpiedInstance = restoreSpiedInstance;
 exports.setEmissionTimeout = setEmissionTimeout;
 exports.settleDynamicImport = settleDynamicImport;
 exports.stubConstructor = stubConstructor;

package/dist/node.d.cts

@@ -24,6 +24,7 @@ export declare const createFunctionSpy: typeof Entry.createFunctionSpy;
 export declare const createMock: typeof Entry.createMock;
 export declare const createSpyClass: typeof Entry.createSpyClass;
 export declare const createSpyFromClass: typeof Entry.createSpyFromClass;
+export declare const createSpyFromInstance: typeof Entry.createSpyFromInstance;
 export declare const describeDuplicateCopies: typeof Entry.describeDuplicateCopies;
 export declare const errorHandler: typeof Entry.errorHandler;
 export declare const expectCompletion: typeof Entry.expectCompletion;
@@ -45,6 +46,7 @@ export declare const narrow: typeof Entry.narrow;
 export declare const pruneNodeMocks: typeof Entry.pruneNodeMocks;
 export declare const resetAutoSpy: typeof Entry.resetAutoSpy;
 export declare const restoreMockedProps: typeof Entry.restoreMockedProps;
+export declare const restoreSpiedInstance: typeof Entry.restoreSpiedInstance;
 export declare const setEmissionTimeout: typeof Entry.setEmissionTimeout;
 export declare const settleDynamicImport: typeof Entry.settleDynamicImport;
 export declare const stubConstructor: typeof Entry.stubConstructor;

package/dist/node.d.ts

@@ -1,6 +1,6 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, S as Spy, t as SpyDisposable, u as SpyOptions, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, y as UnstubbedCallHandler, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.js';
-export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-BDuFuqTb.js';
+export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-Dy5CvsF2.js';
 export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-Dp2ZMFqj.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'vitest';

package/dist/node.js

@@ -1,8 +1,8 @@
 import { createRedefineMockAdapter } from './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-5URFSYDT.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DSIYS6Y5.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-4KCYFAJX.js';
-export { createFunctionSpy, errorHandler } from './chunk-4KK3ES4P.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-GAY6LNAM.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-D5LDT3W4.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-FYFF67EN.js';
+export { createFunctionSpy, errorHandler } from './chunk-FFKN6QKI.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';
@@ -12,6 +12,18 @@ import { registerMockAdapter, guardAccessorSpies } from './shared-state.js';
 function asNodeMock(mockFn) {
   return mockFn;
 }
+function nameImplementation(implementation, name) {
+  if (name === void 0) {
+    return implementation;
+  }
+  const named = {
+    // eslint-disable-next-line object-shorthand -- a concise method is not constructable, and `mockConstructor` has the code under test call `new` on this; a function expression is, and is still named by its computed key.
+    [name]: function(...args) {
+      return implementation.apply(this, args);
+    }
+  };
+  return named[name];
+}
 function nameNodeMock(mockFn, name) {
   if (name !== void 0) {
     Object.defineProperty(mockFn, "displayName", { value: name, configurable: true });
@@ -21,7 +33,7 @@ function nameNodeMock(mockFn, name) {
 function createNodeMockAdapter(nodeTest) {
   return guardAccessorSpies(
     createRedefineMockAdapter({
-      createMockFn: (implementation, name) => nameNodeMock(nodeTest.fn(implementation ?? (() => void 0)), name),
+      createMockFn: (implementation, name) => nameNodeMock(nodeTest.fn(nameImplementation(implementation ?? (() => void 0), name)), name),
       getCalls: (mockFn) => asNodeMock(mockFn).mock.calls.map((call) => call.arguments),
       reset: (mockFn) => asNodeMock(mockFn).mock.resetCalls(),
       // `node:test` mocks reset call history via `resetCalls()`; there is no

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, S as Spy, t as SpyDisposable, u as SpyOptions, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, y as UnstubbedCallHandler, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.js';
-export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-BDuFuqTb.js';
+export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-Dy5CvsF2.js';
 export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-Dp2ZMFqj.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'vitest';