vitest-auto-spy 1.9.2 → 1.9.3

package/dist/angular.cjs

@@ -1 +1,565 @@
-'use strict';var vitest=require('vitest'),testing=require('@angular/core/testing');var m;function w(e){m=e;}var L="No mock adapter registered. Import a runtime entry once before creating spies \u2014 'vitest-auto-spy' (default, Vitest) or a runtime variant such as 'vitest-auto-spy/bun'.";function u(){if(!m)throw new Error(L);return m}var h={createMockFn(e,t){let n=e?vitest.vi.fn(e):vitest.vi.fn();return t!==void 0&&n.mockName(t),n},spyOnGetter(e,t){return vitest.vi.spyOn(e,t,"get")},spyOnSetter(e,t){return vitest.vi.spyOn(e,t,"set")},getCalls(e){return e.mock.calls},reset(e){e.mockReset();},clear(e){e.mockClear();},restoreImplementation(e,t){e.mockImplementation(t);}};var N=Symbol.for("vitest-auto-spy.mock"),U=Symbol.for("vitest-auto-spy.resetConfig"),q=Symbol.for("vitest-auto-spy.clearHook");function y(e){Object.defineProperty(e,N,{value:true,enumerable:false,configurable:true});}function T(e,t){Object.defineProperty(e,U,{value:t,enumerable:false,configurable:true});}function v(e,t){Object.defineProperty(e,q,{value:t,enumerable:false,configurable:true});}function j(e,t){Object.defineProperty(e,t,{get(){},set(n){},configurable:true});}function M(e,t,n){let r=u(),o=n==="setter"?r.spyOnSetter(e,t):r.spyOnGetter(e,t);return y(o),o}function C(e,t,n){let r={getters:{},setters:{}};e.accessorSpies=r,t.forEach(o=>{j(e,o),r.getters[o]=M(e,o,"getter");}),n.forEach(o=>{Object.prototype.hasOwnProperty.call(e,o)||j(e,o),r.setters[o]=M(e,o,"setter");});}function Y(e){return `'${e.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}'`}function J(e,t){return Object.entries(e).map(([n,r])=>`${n}:${i(r,t)}`).join(",")}function X(e,t){return `new Map([${[...e.entries()].map(([r,o])=>`[${i(r,t)},${i(o,t)}]`).join(",")}])`}function Q(e,t){if(t.has(e))return "[Circular]";t.add(e);let n;return e instanceof Date?n=`new Date(${e.getTime()})`:e instanceof Map?n=X(e,t):e instanceof Set?n=`new Set([${[...e].map(r=>i(r,t)).join(",")}])`:Array.isArray(e)?n=`[${e.map(r=>i(r,t)).join(",")}]`:n=`{${J(e,t)}}`,t.delete(e),n}function g(e){return typeof e=="string"?Y(e):typeof e=="bigint"?`${e}n`:typeof e=="symbol"?e.toString():typeof e=="function"?`[Function: ${e.name}]`:Object.is(e,-0)?"-0":String(e)}function O(e){return typeof e=="object"&&e!==null}function i(e,t=new WeakSet){return typeof e=="object"&&e!==null?Q(e,t):g(e)}function R(e){return typeof e=="object"&&e!==null&&"asymmetricMatch"in e&&typeof e.asymmetricMatch=="function"}function Z(e){return e.some(R)}var l=class{#t=Object.create(null);#n=[];set(t,n){if(Array.isArray(t)&&Z(t)){this.#n.push({args:t,value:n});return}this.#t[this.#e(t)]=n;}get(t){let n=this.#e(t);return n in this.#t?this.#t[n]:this.#r(t)}#e(t){return Array.isArray(t)&&!t.some(O)?`[${t.map(n=>g(n)).join(",")}]`:i(t)}#r(t){return Array.isArray(t)?this.#n.find(r=>this.#o(r.args,t))?.value:void 0}#o(t,n){return t.length!==n.length?false:t.every((r,o)=>this.#s(r,n[o]))}#s(t,n){return R(t)?t.asymmetricMatch(n):this.#e([t])===this.#e([n])}};var ee=e=>`The function '${e}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `,te="But the function was called without any arguments.",ne=e=>{let t=i(e);return `But the actual arguments were: ${t.substring(1,t.length-1)}`},A={throwArgumentsError(e,t){let n=e.length===0?te:ne(e);throw new Error(ee(t)+n)}};var re="Observable spies require rxjs. Import 'vitest-auto-spy/rxjs' once (e.g. in your test setup) to enable observablePropsToSpyOn / nextWith / nextWithValues / throwWith / complete / returnSubject.";function P(){throw new Error(re);}function p(e,t){return Object.assign(e,t)}function oe(e){return e.map(t=>({wrappedValue:t.delay===void 0?Promise.resolve(t.value):new Promise(n=>setTimeout(()=>n(t.value),t.delay))}))}function F(e,t){p(e,{resolveWith:n=>{t({value:Promise.resolve(n)});},rejectWith:n=>{t({value:n,_isRejectedPromise:true});},resolveWithPerCall:n=>{n.length!==0&&t({value:void 0,valuesPerCalls:oe(n)});}});}function x(e,t){F(e,n=>{t.value=n.value,t._isRejectedPromise=n._isRejectedPromise??false,t.valuesPerCalls=n.valuesPerCalls??[];});}function V(e,t){F(e,n=>{e.argsToValuesMap.set(t,n);});}var se={record:e=>e,clear:()=>{}};function ie(e){return typeof e!="object"&&typeof e!="function"||e===null?false:typeof Reflect.get(e,"then")=="function"}function E(e){let t=Reflect.get(e,"mock");if(typeof t!="object"||t===null||"settledResults"in t)return se;let n=[];return Object.defineProperty(t,"settledResults",{value:n,enumerable:true,configurable:true,writable:true}),{record(r){let o={type:"incomplete",value:void 0};return n.push(o),ie(r)?r.then(s=>{o.type="fulfilled",o.value=s;},s=>{o.type="rejected",o.value=s;}):(o.type="fulfilled",o.value=r),r},clear(){n.length=0;}}}function ce(e){return typeof e=="object"&&e!==null&&"value"in e}function $(e){if(e._isRejectedPromise)return Promise.reject(e.value);let t=e.valuesPerCalls?.shift();return t?t.wrappedValue:e.value}function W(e,t){let n=e.argsToValuesMap.get(t);return ce(n)?{found:true,value:$(n)}:{found:false,value:void 0}}function ue(e,t,n,r,o){if(e.wasConfigured){let s=W(e,r);if(s.found)return s.value}if(t.wasConfigured){let s=W(t,r);if(s.found)return s.value;A.throwArgumentsError(r,o);}return $(n)}function z(e,t){e.wasConfigured=true;let n=r=>{e.argsToValuesMap.set(t,{value:r});};return p(e,{mockReturnValue:n,returnValue:n}),V(e,t),e}function _(){return {wasConfigured:false,argsToValuesMap:new l}}function H(e){e.wasConfigured=false,e.argsToValuesMap=new l;}function S(e){let t=_(),n=_(),r={value:void 0},o=(...a)=>c.record(ue(t,n,r,a,e)),s=u().createMockFn(o,e),c=E(s);x(s,r);let d=p(s,{calledWith:(...a)=>z(t,a),mustBeCalledWith:(...a)=>z(n,a)});return T(d,()=>{H(t),H(n),r.value=void 0,delete r._isRejectedPromise,delete r.valuesPerCalls,u().restoreImplementation(s,o);}),v(d,()=>c.clear()),y(d),d}var K={methodsToSpyOn:[],observablePropsToSpyOn:[],settersToSpyOn:[],gettersToSpyOn:[],autoSpyAccessors:false,lazySpies:false};function ae(e){let t=Object.getOwnPropertyDescriptors(e);return Object.keys(t).filter(n=>n!=="constructor"&&!t[n]?.get)}function B(e,t){let n=e;for(;n;){let r=Object.getPrototypeOf(n);r&&t(n),n=r;}}var I=new WeakMap;function G(e){let t=I.get(e);if(t)return t;let n=new Set;B(e,o=>ae(o).forEach(s=>n.add(s)));let r=[...n];return I.set(e,r),r}function le(e){let t=new Set,n=new Set;return B(e,r=>{let o=Object.getOwnPropertyDescriptors(r);Object.keys(o).forEach(s=>{s!=="constructor"&&(o[s]?.get&&t.add(s),o[s]?.set&&n.add(s));});}),{getters:[...t],setters:[...n]}}function pe(e,t){if(!t.autoSpyAccessors)return {getters:t.gettersToSpyOn,setters:t.settersToSpyOn};let n=le(e);return {getters:[...new Set([...t.gettersToSpyOn,...n.getters])],setters:[...new Set([...t.settersToSpyOn,...n.setters])]}}function de(e,t){let n=new Set(G(e.prototype)),r=t.filter(o=>!n.has(o));r.length!==0&&console.warn(`[vitest-auto-spy] createSpyFromClass(${e.name}): requested method(s) not found on the class prototype: ${r.join(", ")}. A spy was still created, but the real code will never call it \u2014 check for typos.`);}function fe(e,t){Object.defineProperty(e,t,{configurable:true,enumerable:true,get(){let n=S(t);return Object.defineProperty(e,t,{configurable:true,enumerable:true,writable:true,value:n}),n}});}function ye(e){return e?Array.isArray(e)?{...K,methodsToSpyOn:e}:{methodsToSpyOn:e.methodsToSpyOn??[],observablePropsToSpyOn:e.observablePropsToSpyOn??[],settersToSpyOn:e.settersToSpyOn??[],gettersToSpyOn:e.gettersToSpyOn??[],autoSpyAccessors:e.autoSpyAccessors??false,lazySpies:e.lazySpies??false}:{...K}}function D(e,t){let n=ye(t),r=n.methodsToSpyOn.length>0?n.methodsToSpyOn:G(e.prototype);n.methodsToSpyOn.length>0&&de(e,n.methodsToSpyOn);let o={};n.observablePropsToSpyOn.forEach(c=>{o[c]=P().createPropSpy();});let s=pe(e.prototype,n);return C(o,s.getters,s.setters),r.forEach(c=>{n.lazySpies?fe(o,c):o[c]=S(c);}),o}function ge(e){return e?Array.isArray(e)?{methodsToSpyOn:e,lazySpies:true}:{...e,lazySpies:e.lazySpies??true}:{lazySpies:true}}function ke(e,t){return {provide:e,useValue:D(e,ge(t))}}function be(e){return testing.TestBed.inject(e)}function Se(e,t,n){Object.defineProperty(e,t,{get:()=>n,configurable:true});}function we(e,t,n){Object.defineProperty(e,t,{get:n,configurable:true});}function he(e,t){let n=u();Object.defineProperty(e,t,{get:n.createMockFn(),set:n.createMockFn(),configurable:true});}w(h);exports.injectSpy=be;exports.mockAccessorsProp=he;exports.mockReadonlyProp=Se;exports.mockReadonlyPropGetter=we;exports.provideAutoSpy=ke;
+'use strict';
+
+var vitest = require('vitest');
+var testing = require('@angular/core/testing');
+
+// src/lib/mock-adapter.ts
+var registeredAdapter;
+function registerMockAdapter(adapter) {
+  registeredAdapter = adapter;
+}
+var MISSING_MOCK_ADAPTER = "No mock adapter registered. Import a runtime entry once before creating spies \u2014 'vitest-auto-spy' (default, Vitest) or a runtime variant such as 'vitest-auto-spy/bun'.";
+function getMockAdapter() {
+  if (!registeredAdapter) {
+    throw new Error(MISSING_MOCK_ADAPTER);
+  }
+  return registeredAdapter;
+}
+function asVitestMock(mock) {
+  return mock;
+}
+var vitestMockAdapter = {
+  createMockFn(implementation, name) {
+    const mock = implementation ? vitest.vi.fn(implementation) : vitest.vi.fn();
+    if (name !== void 0) {
+      mock.mockName(name);
+    }
+    return mock;
+  },
+  spyOnGetter(target, property) {
+    return vitest.vi.spyOn(target, property, "get");
+  },
+  spyOnSetter(target, property) {
+    return vitest.vi.spyOn(target, property, "set");
+  },
+  getCalls(mock) {
+    return asVitestMock(mock).mock.calls;
+  },
+  reset(mock) {
+    asVitestMock(mock).mockReset();
+  },
+  clear(mock) {
+    asVitestMock(mock).mockClear();
+  },
+  restoreImplementation(mock, implementation) {
+    asVitestMock(mock).mockImplementation(implementation);
+  }
+};
+
+// 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");
+function markAsMock(mock) {
+  Object.defineProperty(mock, AUTO_SPY_MARK, { value: true, enumerable: false, configurable: true });
+}
+function attachConfigReset(spy, reset) {
+  Object.defineProperty(spy, RESET_CONFIG, { value: reset, enumerable: false, configurable: true });
+}
+function attachClearHook(spy, clear) {
+  Object.defineProperty(spy, CLEAR_HOOK, { value: clear, enumerable: false, configurable: true });
+}
+
+// src/lib/accessor-spy.ts
+function defineWithEmptyAccessors(obj, prop) {
+  Object.defineProperty(obj, prop, {
+    get() {
+      return void 0;
+    },
+    set(_value) {
+    },
+    configurable: true
+  });
+}
+function spyOnAccessor(autoSpy, accessorName, accessorType) {
+  const adapter = getMockAdapter();
+  const mock = accessorType === "setter" ? adapter.spyOnSetter(autoSpy, accessorName) : adapter.spyOnGetter(autoSpy, accessorName);
+  markAsMock(mock);
+  return mock;
+}
+function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn) {
+  const accessorSpies = { getters: {}, setters: {} };
+  autoSpy["accessorSpies"] = accessorSpies;
+  gettersToSpyOn.forEach((getterName) => {
+    defineWithEmptyAccessors(autoSpy, getterName);
+    accessorSpies.getters[getterName] = spyOnAccessor(autoSpy, getterName, "getter");
+  });
+  settersToSpyOn.forEach((setterName) => {
+    if (!Object.prototype.hasOwnProperty.call(autoSpy, setterName)) {
+      defineWithEmptyAccessors(autoSpy, setterName);
+    }
+    accessorSpies.setters[setterName] = spyOnAccessor(autoSpy, setterName, "setter");
+  });
+}
+
+// src/lib/serialize-args.ts
+function quoteString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function serializeEntries(value, seen) {
+  return Object.entries(value).map(([key, entryValue]) => `${key}:${serializeValue(entryValue, seen)}`).join(",");
+}
+function serializeMap(value, seen) {
+  const pairs = [...value.entries()].map(([key, entryValue]) => `[${serializeValue(key, seen)},${serializeValue(entryValue, seen)}]`);
+  return `new Map([${pairs.join(",")}])`;
+}
+function serializeObject(value, seen) {
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  let result;
+  if (value instanceof Date) {
+    result = `new Date(${value.getTime()})`;
+  } else if (value instanceof Map) {
+    result = serializeMap(value, seen);
+  } else if (value instanceof Set) {
+    result = `new Set([${[...value].map((item) => serializeValue(item, seen)).join(",")}])`;
+  } else if (Array.isArray(value)) {
+    result = `[${value.map((item) => serializeValue(item, seen)).join(",")}]`;
+  } else {
+    result = `{${serializeEntries(value, seen)}}`;
+  }
+  seen.delete(value);
+  return result;
+}
+function serializePrimitive(value) {
+  if (typeof value === "string") {
+    return quoteString(value);
+  }
+  if (typeof value === "bigint") {
+    return `${value}n`;
+  }
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name}]`;
+  }
+  if (Object.is(value, -0)) {
+    return "-0";
+  }
+  return String(value);
+}
+function isDeepValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function serializeValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "object" && value !== null) {
+    return serializeObject(value, seen);
+  }
+  return serializePrimitive(value);
+}
+
+// src/lib/args-map.ts
+function isAsymmetricMatcher(value) {
+  return typeof value === "object" && value !== null && "asymmetricMatch" in value && typeof value.asymmetricMatch === "function";
+}
+function hasAsymmetricMatcher(args) {
+  return args.some(isAsymmetricMatcher);
+}
+var ArgsMap = class {
+  // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
+  // plain own property, never walking or polluting the object prototype chain.
+  #map = /* @__PURE__ */ Object.create(null);
+  #matcherConfigs = [];
+  set(key, value) {
+    if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
+      this.#matcherConfigs.push({ args: key, value });
+      return;
+    }
+    this.#map[this.#serialize(key)] = value;
+  }
+  get(key) {
+    const serialized = this.#serialize(key);
+    if (serialized in this.#map) {
+      return this.#map[serialized];
+    }
+    return this.#findByMatcher(key);
+  }
+  // Keys are always argument arrays; `serializeValue` renders them to a stable,
+  // total string (single-quoted strings, bracketed arrays, distinct `undefined`
+  // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of
+  // only primitive args take a fast path that skips the circular-ref bookkeeping.
+  #serialize(key) {
+    if (Array.isArray(key) && !key.some(isDeepValue)) {
+      return `[${key.map((arg) => serializePrimitive(arg)).join(",")}]`;
+    }
+    return serializeValue(key);
+  }
+  /** Return the value of the first asymmetric config whose predicate matches the actual args. */
+  #findByMatcher(actualArgs) {
+    if (!Array.isArray(actualArgs)) {
+      return void 0;
+    }
+    const match = this.#matcherConfigs.find((config) => this.#argsMatch(config.args, actualArgs));
+    return match?.value;
+  }
+  /** Whether every configured arg matches the actual arg at the same position (same length). */
+  #argsMatch(configArgs, actualArgs) {
+    if (configArgs.length !== actualArgs.length) {
+      return false;
+    }
+    return configArgs.every((configArg, index) => this.#valueMatches(configArg, actualArgs[index]));
+  }
+  /** Match a single arg: asymmetric matchers delegate to `asymmetricMatch`, others compare by serialization. */
+  #valueMatches(configArg, actualArg) {
+    if (isAsymmetricMatcher(configArg)) {
+      return configArg.asymmetricMatch(actualArg);
+    }
+    return this.#serialize([configArg]) === this.#serialize([actualArg]);
+  }
+};
+
+// src/lib/error-handler.ts
+var MUST_BE_CALLED_WITH_PREAMBLE = (functionName) => `The function '${functionName}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `;
+var NO_ARGUMENTS_MESSAGE = `But the function was called without any arguments.`;
+var actualArgumentsMessage = (actualArgs) => {
+  const formatted = serializeValue(actualArgs);
+  return `But the actual arguments were: ${formatted.substring(1, formatted.length - 1)}`;
+};
+var errorHandler = {
+  throwArgumentsError(actualArgs, functionName) {
+    const detail = actualArgs.length === 0 ? NO_ARGUMENTS_MESSAGE : actualArgumentsMessage(actualArgs);
+    throw new Error(MUST_BE_CALLED_WITH_PREAMBLE(functionName) + detail);
+  }
+};
+var MISSING_RXJS_SUPPORT = "Observable spies require rxjs. Import 'vitest-auto-spy/rxjs' once (e.g. in your test setup) to enable observablePropsToSpyOn / nextWith / nextWithValues / throwWith / complete / returnSubject.";
+function requireObservableSupport() {
+  {
+    throw new Error(MISSING_RXJS_SUPPORT);
+  }
+}
+
+// src/lib/spy-decoration.ts
+function decorate(target, helpers) {
+  return Object.assign(target, helpers);
+}
+
+// src/lib/promise-spy.ts
+function toResolvedPerCallValues(valueConfigsPerCall) {
+  return valueConfigsPerCall.map((config) => ({
+    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) });
+    },
+    rejectWith: (value) => {
+      store({ value, _isRejectedPromise: true });
+    },
+    resolveWithPerCall: (valueConfigsPerCall) => {
+      if (valueConfigsPerCall.length === 0) {
+        return;
+      }
+      store({ value: void 0, valuesPerCalls: toResolvedPerCallValues(valueConfigsPerCall) });
+    }
+  });
+}
+function addPromiseHelpersToFunctionSpy(spyFunction, valueContainer) {
+  addPromiseHelpers(spyFunction, (container) => {
+    valueContainer.value = container.value;
+    valueContainer._isRejectedPromise = container._isRejectedPromise ?? false;
+    valueContainer.valuesPerCalls = container.valuesPerCalls ?? [];
+  });
+}
+function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
+  addPromiseHelpers(calledWithObject, (container) => {
+    calledWithObject.argsToValuesMap.set(calledWithArgs, container);
+  });
+}
+
+// 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) {
+  const state = Reflect.get(mockFn, "mock");
+  if (typeof state !== "object" || state === null || "settledResults" in state) {
+    return NATIVE_RECORDER;
+  }
+  const settledResults = [];
+  Object.defineProperty(state, "settledResults", { value: settledResults, enumerable: true, configurable: true, writable: true });
+  return {
+    record(returned) {
+      const entry = { type: "incomplete", value: void 0 };
+      settledResults.push(entry);
+      if (isThenable(returned)) {
+        returned.then(
+          (value) => {
+            entry.type = "fulfilled";
+            entry.value = value;
+          },
+          (reason) => {
+            entry.type = "rejected";
+            entry.value = reason;
+          }
+        );
+      } else {
+        entry.type = "fulfilled";
+        entry.value = returned;
+      }
+      return returned;
+    },
+    clear() {
+      settledResults.length = 0;
+    }
+  };
+}
+
+// src/lib/function-spy.ts
+function isReturnValueContainer(value) {
+  return typeof value === "object" && value !== null && "value" in value;
+}
+function unwrapContainer(container) {
+  if (container._isRejectedPromise) {
+    return Promise.reject(container.value);
+  }
+  const wrapped = container.valuesPerCalls?.shift();
+  if (wrapped) {
+    return wrapped.wrappedValue;
+  }
+  return container.value;
+}
+function lookupConfigured(calledWithObject, actualArgs) {
+  const configured = calledWithObject.argsToValuesMap.get(actualArgs);
+  if (isReturnValueContainer(configured)) {
+    return { found: true, value: unwrapContainer(configured) };
+  }
+  return { found: false, value: void 0 };
+}
+function returnTheCorrectFakeValue(calledWithObject, mustBeCalledWithObject, valueContainer, actualArgs, functionName) {
+  if (calledWithObject.wasConfigured) {
+    const match = lookupConfigured(calledWithObject, actualArgs);
+    if (match.found) {
+      return match.value;
+    }
+  }
+  if (mustBeCalledWithObject.wasConfigured) {
+    const match = lookupConfigured(mustBeCalledWithObject, actualArgs);
+    if (match.found) {
+      return match.value;
+    }
+    errorHandler.throwArgumentsError(actualArgs, functionName);
+  }
+  return unwrapContainer(valueContainer);
+}
+function addMethodsToCalledWith(calledWith, calledWithArgs) {
+  calledWith.wasConfigured = true;
+  const setReturnValue = (value) => {
+    calledWith.argsToValuesMap.set(calledWithArgs, { value });
+  };
+  decorate(calledWith, {
+    mockReturnValue: setReturnValue,
+    // `returnValue` is the `jest-auto-spies` name — aliased so migrating tests need no rewrite.
+    returnValue: setReturnValue
+  });
+  addPromiseHelpersToCalledWithObject(calledWith, calledWithArgs);
+  return calledWith;
+}
+function createCalledWithObject() {
+  return { wasConfigured: false, argsToValuesMap: new ArgsMap() };
+}
+function resetCalledWithObject(calledWithObject) {
+  calledWithObject.wasConfigured = false;
+  calledWithObject.argsToValuesMap = new ArgsMap();
+}
+function createFunctionSpy(name) {
+  const calledWithObject = createCalledWithObject();
+  const mustBeCalledWithObject = createCalledWithObject();
+  const valueContainer = { value: void 0 };
+  const dispatch = (...actualArgs) => settledResultsRecorder.record(returnTheCorrectFakeValue(calledWithObject, mustBeCalledWithObject, valueContainer, actualArgs, name));
+  const functionSpy = getMockAdapter().createMockFn(dispatch, name);
+  const settledResultsRecorder = installSettledResultsPolyfill(functionSpy);
+  addPromiseHelpersToFunctionSpy(functionSpy, valueContainer);
+  const spy = decorate(functionSpy, {
+    calledWith: (...calledWithArgs) => addMethodsToCalledWith(calledWithObject, calledWithArgs),
+    mustBeCalledWith: (...calledWithArgs) => addMethodsToCalledWith(mustBeCalledWithObject, calledWithArgs)
+  });
+  attachConfigReset(spy, () => {
+    resetCalledWithObject(calledWithObject);
+    resetCalledWithObject(mustBeCalledWithObject);
+    valueContainer.value = void 0;
+    delete valueContainer._isRejectedPromise;
+    delete valueContainer.valuesPerCalls;
+    getMockAdapter().restoreImplementation(functionSpy, dispatch);
+  });
+  attachClearHook(spy, () => settledResultsRecorder.clear());
+  markAsMock(spy);
+  return exposeAsSpy(spy);
+}
+function exposeAsSpy(spy) {
+  return spy;
+}
+
+// src/lib/create-spy-from-class.ts
+var EMPTY_CONFIGURATION = {
+  methodsToSpyOn: [],
+  observablePropsToSpyOn: [],
+  settersToSpyOn: [],
+  gettersToSpyOn: [],
+  autoSpyAccessors: false,
+  lazySpies: false
+};
+function extractMethodsFromObject(obj) {
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  return Object.keys(descriptors).filter((name) => name !== "constructor" && !descriptors[name]?.get);
+}
+function walkOwnPrototypes(prototype, visit) {
+  let current = prototype;
+  while (current) {
+    const parent = Object.getPrototypeOf(current);
+    if (parent) {
+      visit(current);
+    }
+    current = parent;
+  }
+}
+var methodNamesCache = /* @__PURE__ */ new WeakMap();
+function getAllMethodNames(prototype) {
+  const cached = methodNamesCache.get(prototype);
+  if (cached) {
+    return cached;
+  }
+  const methods = /* @__PURE__ */ new Set();
+  walkOwnPrototypes(prototype, (obj) => extractMethodsFromObject(obj).forEach((name) => methods.add(name)));
+  const result = [...methods];
+  methodNamesCache.set(prototype, result);
+  return result;
+}
+function getAllAccessorNames(prototype) {
+  const getters = /* @__PURE__ */ new Set();
+  const setters = /* @__PURE__ */ new Set();
+  walkOwnPrototypes(prototype, (obj) => {
+    const descriptors = Object.getOwnPropertyDescriptors(obj);
+    Object.keys(descriptors).forEach((name) => {
+      if (name === "constructor") {
+        return;
+      }
+      if (descriptors[name]?.get) {
+        getters.add(name);
+      }
+      if (descriptors[name]?.set) {
+        setters.add(name);
+      }
+    });
+  });
+  return { getters: [...getters], setters: [...setters] };
+}
+function resolveAccessors(prototype, config) {
+  if (!config.autoSpyAccessors) {
+    return { getters: config.gettersToSpyOn, setters: config.settersToSpyOn };
+  }
+  const discovered = getAllAccessorNames(prototype);
+  return {
+    getters: [.../* @__PURE__ */ new Set([...config.gettersToSpyOn, ...discovered.getters])],
+    setters: [.../* @__PURE__ */ new Set([...config.settersToSpyOn, ...discovered.setters])]
+  };
+}
+function warnOnUnknownMethods(ObjectClass, requested) {
+  const available = new Set(getAllMethodNames(ObjectClass.prototype));
+  const unknown = requested.filter((name) => !available.has(name));
+  if (unknown.length === 0) {
+    return;
+  }
+  console.warn(
+    `[vitest-auto-spy] createSpyFromClass(${ObjectClass.name}): requested method(s) not found on the class prototype: ${unknown.join(", ")}. A spy was still created, but the real code will never call it \u2014 check for typos.`
+  );
+}
+function defineLazyMethodSpy(autoSpy, methodName) {
+  Object.defineProperty(autoSpy, methodName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const spy = createFunctionSpy(methodName);
+      Object.defineProperty(autoSpy, methodName, { configurable: true, enumerable: true, writable: true, value: spy });
+      return spy;
+    }
+  });
+}
+function resolveConfiguration(methodsToSpyOnOrConfig) {
+  if (!methodsToSpyOnOrConfig) {
+    return { ...EMPTY_CONFIGURATION };
+  }
+  if (Array.isArray(methodsToSpyOnOrConfig)) {
+    return { ...EMPTY_CONFIGURATION, methodsToSpyOn: methodsToSpyOnOrConfig };
+  }
+  return {
+    methodsToSpyOn: methodsToSpyOnOrConfig.methodsToSpyOn ?? [],
+    observablePropsToSpyOn: methodsToSpyOnOrConfig.observablePropsToSpyOn ?? [],
+    settersToSpyOn: methodsToSpyOnOrConfig.settersToSpyOn ?? [],
+    gettersToSpyOn: methodsToSpyOnOrConfig.gettersToSpyOn ?? [],
+    autoSpyAccessors: methodsToSpyOnOrConfig.autoSpyAccessors ?? false,
+    lazySpies: methodsToSpyOnOrConfig.lazySpies ?? false
+  };
+}
+function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
+  const config = resolveConfiguration(methodsToSpyOnOrConfig);
+  const methodNames = config.methodsToSpyOn.length > 0 ? config.methodsToSpyOn : getAllMethodNames(ObjectClass.prototype);
+  if (config.methodsToSpyOn.length > 0) {
+    warnOnUnknownMethods(ObjectClass, config.methodsToSpyOn);
+  }
+  const autoSpy = {};
+  config.observablePropsToSpyOn.forEach((observablePropName) => {
+    autoSpy[observablePropName] = requireObservableSupport().createPropSpy();
+  });
+  const accessors = resolveAccessors(ObjectClass.prototype, config);
+  createAccessorsSpies(autoSpy, accessors.getters, accessors.setters);
+  methodNames.forEach((methodName) => {
+    if (config.lazySpies) {
+      defineLazyMethodSpy(autoSpy, methodName);
+    } else {
+      autoSpy[methodName] = createFunctionSpy(methodName);
+    }
+  });
+  return autoSpy;
+}
+
+// src/lib/angular.ts
+function withLazyDefault(methodsToSpyOnOrConfig) {
+  if (!methodsToSpyOnOrConfig) {
+    return { lazySpies: true };
+  }
+  if (Array.isArray(methodsToSpyOnOrConfig)) {
+    return { methodsToSpyOn: methodsToSpyOnOrConfig, lazySpies: true };
+  }
+  return { ...methodsToSpyOnOrConfig, lazySpies: methodsToSpyOnOrConfig.lazySpies ?? true };
+}
+function provideAutoSpy(ObjectClass, methodsToSpyOnOrConfig) {
+  return {
+    provide: ObjectClass,
+    useValue: createSpyFromClass(ObjectClass, withLazyDefault(methodsToSpyOnOrConfig))
+  };
+}
+function injectSpy(token) {
+  const injected = testing.TestBed.inject(token);
+  return injected;
+}
+function mockReadonlyProp(object, property, value) {
+  Object.defineProperty(object, property, { get: () => value, configurable: true });
+}
+function mockReadonlyPropGetter(object, property, getter) {
+  Object.defineProperty(object, property, { get: getter, configurable: true });
+}
+function mockAccessorsProp(object, property) {
+  const adapter = getMockAdapter();
+  Object.defineProperty(object, property, { get: adapter.createMockFn(), set: adapter.createMockFn(), configurable: true });
+}
+
+// src/angular.ts
+registerMockAdapter(vitestMockAdapter);
+
+exports.injectSpy = injectSpy;
+exports.mockAccessorsProp = mockAccessorsProp;
+exports.mockReadonlyProp = mockReadonlyProp;
+exports.mockReadonlyPropGetter = mockReadonlyPropGetter;
+exports.provideAutoSpy = provideAutoSpy;

package/dist/angular.js

@@ -1 +1,40 @@
-import {a as a$1}from'./chunk-HDCUMVHT.js';import {a as a$2}from'./chunk-Q4FBVCJO.js';import {a,c as c$1}from'./chunk-RTGT5WHR.js';import'./chunk-7IUYJ6ZW.js';import {TestBed}from'@angular/core/testing';function s(e){return e?Array.isArray(e)?{methodsToSpyOn:e,lazySpies:true}:{...e,lazySpies:e.lazySpies??true}:{lazySpies:true}}function y(e,r){return {provide:e,useValue:a$2(e,s(r))}}function u(e){return TestBed.inject(e)}function c(e,r,t){Object.defineProperty(e,r,{get:()=>t,configurable:true});}function l(e,r,t){Object.defineProperty(e,r,{get:t,configurable:true});}function T(e,r){let t=c$1();Object.defineProperty(e,r,{get:t.createMockFn(),set:t.createMockFn(),configurable:true});}a(a$1);export{u as injectSpy,T as mockAccessorsProp,c as mockReadonlyProp,l as mockReadonlyPropGetter,y as provideAutoSpy};
+import { vitestMockAdapter } from './chunk-OS2QFTIF.js';
+import { createSpyFromClass } from './chunk-JXCO3VHG.js';
+import { registerMockAdapter, getMockAdapter } from './chunk-T4Q3C2PV.js';
+import './chunk-5JKCB5CM.js';
+import { TestBed } from '@angular/core/testing';
+
+function withLazyDefault(methodsToSpyOnOrConfig) {
+  if (!methodsToSpyOnOrConfig) {
+    return { lazySpies: true };
+  }
+  if (Array.isArray(methodsToSpyOnOrConfig)) {
+    return { methodsToSpyOn: methodsToSpyOnOrConfig, lazySpies: true };
+  }
+  return { ...methodsToSpyOnOrConfig, lazySpies: methodsToSpyOnOrConfig.lazySpies ?? true };
+}
+function provideAutoSpy(ObjectClass, methodsToSpyOnOrConfig) {
+  return {
+    provide: ObjectClass,
+    useValue: createSpyFromClass(ObjectClass, withLazyDefault(methodsToSpyOnOrConfig))
+  };
+}
+function injectSpy(token) {
+  const injected = TestBed.inject(token);
+  return injected;
+}
+function mockReadonlyProp(object, property, value) {
+  Object.defineProperty(object, property, { get: () => value, configurable: true });
+}
+function mockReadonlyPropGetter(object, property, getter) {
+  Object.defineProperty(object, property, { get: getter, configurable: true });
+}
+function mockAccessorsProp(object, property) {
+  const adapter = getMockAdapter();
+  Object.defineProperty(object, property, { get: adapter.createMockFn(), set: adapter.createMockFn(), configurable: true });
+}
+
+// src/angular.ts
+registerMockAdapter(vitestMockAdapter);
+
+export { injectSpy, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, provideAutoSpy };