vitest-auto-spy 4.2.0 → 4.3.0

package/dist/{chunk-5URFSYDT.js → chunk-GAY6LNAM.js}

@@ -1,11 +1,65 @@
-import { mockValueProp } from './chunk-DSIYS6Y5.js';
-import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-4KCYFAJX.js';
-import { defineHelper, serializeValue, createFunctionSpy } from './chunk-4KK3ES4P.js';
+import { redefineFailure, mockValueProp, mockAccessorsProp } from './chunk-D5LDT3W4.js';
+import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-FYFF67EN.js';
+import { defineHelper, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-FFKN6QKI.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
 import { DEEP_CHILDREN } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';
-import { getMockAdapter } from './shared-state.js';
-export { describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, getPackageCopies, setEmissionTimeout } from './shared-state.js';
+import { requireObservableSupport, getMockAdapter, emissionTimeout } from './shared-state.js';
+export { describeDuplicateCopies, getPackageCopies, setEmissionTimeout } from './shared-state.js';
+
+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) {
@@ -202,6 +256,246 @@ function captureArg() {
   return new Captor();
 }
 
+// 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 anchorOf(stack, boundaryName) {
+  const frames = framesAfter(frameLines(stack), boundaryName);
+  return (error) => anchor(frames, error);
+}
+function captureAnchor(boundary, host = Error) {
+  const holder = new Error();
+  const capture = host.captureStackTrace;
+  if (capture) {
+    capture(holder, boundary);
+    return anchorOf(holder.stack, "");
+  }
+  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 frameLines(stack) {
+  const lines = String(stack).split("\n");
+  const first = lines.findIndex(isFrame);
+  return first < 0 ? [] : lines.slice(first);
+}
+function isFrame(line) {
+  return /^\s*at\s/.test(line) || /^\S*@/.test(line);
+}
+function framesAfter(frames, boundaryName) {
+  const boundary = boundaryName === "" ? -1 : frames.findIndex((frame) => frame.includes(boundaryName));
+  return boundary < 0 ? frames : frames.slice(boundary + 1);
+}
+function subscribeToSource(source$, observer) {
+  if (isRxjsSource(source$)) {
+    return source$.subscribe(observer);
+  }
+  return source$.subscribe(asHybridObserver(observer));
+}
+function isRxjsSource(source$) {
+  return typeof Reflect.get(source$, "pipe") === "function";
+}
+function asHybridObserver(observer) {
+  const listener = (value) => observer.next(value);
+  return Object.assign(listener, observer);
+}
+var setTimer = globalThis.setTimeout.bind(globalThis);
+var clearTimer = globalThis.clearTimeout.bind(globalThis);
+function describeSource(options) {
+  return options?.label ?? "the observable";
+}
+function accepted(values, options) {
+  const past = options?.skip ? values.slice(options.skip) : values;
+  const until = options?.until;
+  return until ? past.filter((value) => until(value)) : past;
+}
+function describeExpectation(count, options) {
+  return options?.until ? `${count} matching` : String(count);
+}
+function subscribeAndCollect(source$, options, settle, handlers) {
+  const values = [];
+  let subscription = void 0;
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+    clearTimer(timer);
+    subscription?.unsubscribe();
+  };
+  const timeout = options?.timeout ?? emissionTimeout();
+  const timer = timeout > 0 ? setTimer(() => {
+    stop();
+    settle.reject(handlers.onTimeout(values, options, timeout));
+  }, timeout) : void 0;
+  subscription = subscribeToSource(source$, {
+    next: (value) => {
+      values.push(value);
+      if (handlers.isDone(values)) {
+        stop();
+        settle.resolve(values);
+      }
+    },
+    error: (error) => {
+      stop();
+      handlers.onError(error, options, settle);
+    },
+    complete: () => {
+      stop();
+      handlers.onComplete(values);
+    }
+  });
+  if (stopped) {
+    subscription.unsubscribe();
+  }
+  if (!stopped) {
+    options?.advance?.();
+  }
+  return { values, stop };
+}
+function anchoredRejecter(reject, anchor2) {
+  return (error) => reject(anchor2(error));
+}
+function timeoutError(values, options, waited) {
+  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(ownFailure(`${describeSource(options)} errored instead of emitting: ${String(error)}`, { cause: error }));
+}
+function completedError(values, expected, options) {
+  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, captureAnchor(expectEmission)).then((values) => firstOf(values));
+}
+function firstOf(values) {
+  return values[0];
+}
+function expectEmissions(source$, count, options) {
+  return collectEmissions(source$, count, options, captureAnchor(expectEmissions));
+}
+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: fail },
+      {
+        isDone: (values) => accepted(values, options).length >= count,
+        onComplete: (values) => fail(completedError(values, count, options)),
+        onTimeout: timeoutError,
+        onError: rejectAsSourceError
+      }
+    );
+  });
+}
+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) => fail(unexpectedEmissionError(accepted(emitted, options), options)),
+        reject: fail
+      },
+      {
+        isDone: (values) => accepted(values, options).length > 0,
+        onComplete: () => void 0,
+        // Never reached — the watchdog is off (`timeout: 0`) and the quiet window below is this
+        // helper's own timer. Named rather than inlined so it is not an uncalled arrow.
+        onTimeout: timeoutError,
+        onError: rejectAsSourceError
+      }
+    );
+    quietWindow = setTimer(() => {
+      collector.stop();
+      resolve();
+    }, quietFor);
+  }).finally(() => {
+    clearTimer(quietWindow);
+  });
+}
+function expectCompletion(source$, options) {
+  const anchor2 = captureAnchor(expectCompletion);
+  return new Promise((resolve, reject) => {
+    subscribeAndCollect(
+      source$,
+      options,
+      { resolve, reject: anchoredRejecter(reject, anchor2) },
+      {
+        // Emissions are collected for the failure message, but only completion settles this.
+        isDone: staysOpen,
+        onComplete: resolve,
+        onTimeout: notCompletedError,
+        onError: rejectAsNotCompleted
+      }
+    );
+  }).then(() => void 0);
+}
+function staysOpen() {
+  return false;
+}
+function notCompletedError(values, options, waited) {
+  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(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: fail },
+      {
+        // Only `error` settles this one: an emission is not the answer, and neither is completion.
+        isDone: staysOpen,
+        onComplete: (values) => fail(completedWithoutErrorError(values, options)),
+        onTimeout: notErroredError,
+        onError: resolveWithError
+      }
+    );
+  }).then((values) => firstOf(values));
+}
+function completedWithoutErrorError(values, options) {
+  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 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.`
+  );
+}
+function resolveWithError(error, _options, settle) {
+  settle.resolve([error]);
+}
+function unexpectedEmissionError(values, options) {
+  return ownFailure(`${describeSource(options)} emitted ${serializeValue(values[0])} but was expected to stay silent.`);
+}
+
 // src/lib/spy-typing.ts
 function asInstance(spy) {
   return spy;
@@ -428,4 +722,4 @@ function isLenientKey(property) {
   return typeof property === "string" && property !== "then";
 }
 
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, settleDynamicImport, stubConstructor, withOverrides };
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides };

package/dist/{chunk-WQZ2RKS7.js → chunk-KYAJCFUA.js}

@@ -1,5 +1,5 @@
 import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
-import { isThenable, FAST_SPY_BRAND } from './chunk-4KK3ES4P.js';
+import { isThenable, FAST_SPY_BRAND } from './chunk-FFKN6QKI.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
 import { vi } from 'vitest';
 import { guardAccessorSpies } from './shared-state.js';

package/dist/{chunk-KEKKEIRG.js → chunk-Z4VRMCW2.js}

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