vitest-auto-spy 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexey Popov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,233 @@
+# vitest-auto-spy
+
+Create automatic, fully-typed test spies from a class — powered by Vitest's `vi.fn()`.
+
+A **drop-in replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spies)**:
+the same API (`createSpyFromClass`, `provideAutoSpy`, `calledWith`, `resolveWith`,
+`nextWith`, `accessorSpies`, …), but spying only on **Vitest** instead of Jest.
+
+```bash
+npm i -D vitest-auto-spy
+```
+
+Peer dependencies (provided by your project): `vitest`, `rxjs`, and — for the Angular
+helpers — `@angular/core`.
+
+---
+
+## Why
+
+Manually mocking a service is tedious and brittle:
+
+```ts
+// 😫  the old way
+const userService = {
+  getUser: vi.fn(),
+  getUserList: vi.fn(),
+  // ...one line per method, kept in sync by hand
+};
+```
+
+`createSpyFromClass` reads the class and generates a typed spy for **every** method:
+
+```ts
+// 😎  the auto-spy way
+let userService: Spy<UserService>;
+
+beforeEach(() => {
+  userService = createSpyFromClass(UserService);
+});
+```
+
+`Spy<UserService>` exposes each method as a `vi.fn()` **plus** the right helpers based on
+the method's return type (sync / `Promise` / `Observable`).
+
+---
+
+## Configuration
+
+```ts
+// 1. all methods (default)
+createSpyFromClass(MyService);
+
+// 2. only these methods
+createSpyFromClass(MyService, ['getName', 'getAge']);
+
+// 3. full config object
+createSpyFromClass(MyService, {
+  methodsToSpyOn: ['getName'],
+  observablePropsToSpyOn: ['products$'], // Observable *properties*
+  gettersToSpyOn: ['userName'],
+  settersToSpyOn: ['userName'],
+});
+```
+
+---
+
+## Synchronous methods
+
+```ts
+// standard vi.fn() API works as-is
+myService.getName.mockReturnValue('Fake Name');
+
+// return a value only for specific arguments
+myService.getName.calledWith(1).mockReturnValue('Fake Name');
+expect(myService.getName(1)).toBe('Fake Name');
+expect(myService.getName(2)).toBeUndefined();
+
+// throw if called with the "wrong" arguments
+myService.getName.mustBeCalledWith(1).mockReturnValue('Fake Name');
+expect(() => myService.getName(2)).toThrow();
+```
+
+---
+
+## Promise-returning methods
+
+```ts
+myService.getProducts.resolveWith([{ name: 'Product 1' }]);
+await expect(myService.getProducts()).resolves.toEqual([{ name: 'Product 1' }]);
+
+myService.getProducts.rejectWith('FAKE ERROR');
+await expect(myService.getProducts()).rejects.toBe('FAKE ERROR');
+
+// per-call values, and conditional-by-args
+myService.getProducts.resolveWithPerCall([{ value: ['a'] }, { value: ['b'] }]);
+myService.getProducts.calledWith(1).resolveWith(['one']);
+```
+
+---
+
+## Observable-returning methods & Observable properties
+
+Both spied **methods** that return an `Observable` and spied **properties** of type
+`Observable` get the same control surface:
+
+```ts
+myService.getProducts$.nextWith([{ name: 'Product 1' }]); // emit, stream stays open
+myService.getProducts$.nextOneTimeWith([{ name: 'X' }]);  // emit one value, then complete
+myService.getProducts$.throwWith('FAKE ERROR');           // error the stream
+myService.getProducts$.complete();                        // complete the stream
+
+// emit a precise sequence — values, errors, completion, optional delays
+myService.getProducts$.nextWithValues([
+  { value: [{ name: 'Product 1' }] },
+  { errorValue: 'FAKE ERROR' },
+  { complete: true },
+]);
+
+// a fresh stream per call
+myService.getProducts$.nextWithPerCall([{ value: ['a'] }, { value: ['b'] }]);
+
+// grab the underlying Subject for full manual control
+const subject = myService.getProducts$.returnSubject();
+subject.next([{ name: 'manual' }]);
+```
+
+`calledWith(...)` / `mustBeCalledWith(...)` also chain into the observable helpers:
+
+```ts
+myService.getProducts$.calledWith(1).nextWith([{ name: 'Product 1' }]);
+```
+
+### Standalone observable builder
+
+```ts
+import { createObservableWithValues } from 'vitest-auto-spy';
+
+const fake$ = createObservableWithValues([{ value: 1 }, { value: 2 }, { complete: true }]);
+
+// or get the subject too
+const { values$, subject } = createObservableWithValues([{ value: 1 }], { returnSubject: true });
+```
+
+---
+
+## Getters & setters
+
+```ts
+const spy = createSpyFromClass(MyService, {
+  gettersToSpyOn: ['userName'],
+  settersToSpyOn: ['userName'],
+});
+
+// configure / assert the getter
+spy.accessorSpies.getters.userName.mockReturnValue('Fake Name');
+expect(spy.userName).toBe('Fake Name');
+
+// assert the setter was called
+spy.userName = 'New Name';
+expect(spy.accessorSpies.setters.userName).toHaveBeenCalledWith('New Name');
+```
+
+---
+
+## Angular helpers
+
+`provideAutoSpy` is the shorthand for providing an auto-spy in a `TestBed`:
+
+```ts
+import { provideAutoSpy, injectSpy } from 'vitest-auto-spy';
+
+TestBed.configureTestingModule({
+  providers: [
+    provideAutoSpy(MyService),
+    // accepts the same second argument as createSpyFromClass
+    provideAutoSpy(ApiService, { methodsToSpyOn: ['get', 'post'] }),
+  ],
+});
+
+let myService: Spy<MyService>;
+
+beforeEach(() => {
+  myService = injectSpy(MyService);
+});
+```
+
+> The spies are change-detection agnostic, so they work in **both zoneless and
+> zone.js** Angular projects — nothing here touches `NgZone` or change detection.
+> You only need the usual Vitest + Angular wiring:
+> [`@analogjs/vite-plugin-angular`](https://www.npmjs.com/package/@analogjs/vite-plugin-angular)
+> plus a TestBed setup file (e.g. `@analogjs/vitest-angular`'s `setupTestBed()`).
+
+### Signal / readonly property mocking (bonus)
+
+```ts
+import { mockReadonlyProp, mockReadonlyPropGetter, mockAccessorsProp } from 'vitest-auto-spy';
+
+mockReadonlyProp(service, 'isReady', true);              // static value (incl. signals)
+mockReadonlyPropGetter(service, 'label', () => 'A');     // dynamic getter
+mockAccessorsProp(service, 'theme');                     // spied get + set
+```
+
+---
+
+## API reference
+
+| Export | Description |
+| --- | --- |
+| `createSpyFromClass(Class, methodsOrConfig?)` | Build a fully-typed `Spy<T>` from a class |
+| `provideAutoSpy(Class, methodsOrConfig?)` | Angular `{ provide, useValue }` shorthand |
+| `injectSpy(token)` | `TestBed.inject` typed as `Spy<T>` |
+| `createFunctionSpy(name)` | A single standalone function spy with all helpers |
+| `createObservableWithValues(configs, opts?)` | Build an Observable from value configs |
+| `mockReadonlyProp` / `mockReadonlyPropGetter` / `mockAccessorsProp` | Mock readonly / accessor / signal props |
+| `errorHandler` | The `mustBeCalledWith` argument-mismatch error helper |
+
+**Spied sync method:** `mockReturnValue`, `calledWith(...)`, `mustBeCalledWith(...)`
+
+**Spied Promise method:** `resolveWith`, `rejectWith`, `resolveWithPerCall`
+
+**Spied Observable method / property:** `nextWith`, `nextOneTimeWith`, `nextWithValues`,
+`nextWithPerCall`, `throwWith`, `complete`, `returnSubject`
+
+**Config (`ClassSpyConfiguration`):** `methodsToSpyOn`, `observablePropsToSpyOn`,
+`gettersToSpyOn`, `settersToSpyOn`
+
+`ValueConfig` (for `nextWithValues`): `{ value, delay? }` | `{ errorValue, delay? }` | `{ complete?, delay? }`.
+
+---
+
+## License
+
+MIT © Alexey Popov

package/dist/index.cjs

@@ -0,0 +1,369 @@
+'use strict';
+
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+var testing = require('@angular/core/testing');
+var javascriptStringify = require('javascript-stringify');
+var vitest = require('vitest');
+
+// src/auto-spy.ts
+var ArgsMap = class {
+  constructor() {
+    this.map = {};
+  }
+  // `stringify` always serializes an argument array to a string, so the cast is safe.
+  set(key, value) {
+    this.map[javascriptStringify.stringify(key)] = value;
+  }
+  get(key) {
+    return this.map[javascriptStringify.stringify(key)];
+  }
+};
+var errorHandler = {
+  throwArgumentsError(actualArgs, functionName) {
+    let errorMessage = `The function '${functionName}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `;
+    if (actualArgs.length === 0) {
+      errorMessage += `But the function was called without any arguments.`;
+    } else {
+      let formattedArgs = javascriptStringify.stringify(actualArgs);
+      formattedArgs = formattedArgs.substring(1, formattedArgs.length - 1);
+      errorMessage += `But the actual arguments were: ${formattedArgs}`;
+    }
+    throw new Error(errorMessage);
+  }
+};
+function createReplaySubject() {
+  return new rxjs.ReplaySubject(1);
+}
+function mergeSubjectWithDefaultValues(subject, valuesConfigs) {
+  const onCompleteSubject = new rxjs.ReplaySubject(1);
+  const results$ = rxjs.from(valuesConfigs).pipe(
+    operators.concatMap((valueConfig) => {
+      if ("complete" in valueConfig && valueConfig.complete && valueConfig.delay) {
+        return rxjs.of(valueConfig).pipe(operators.delay(valueConfig.delay));
+      }
+      return rxjs.of(valueConfig);
+    }),
+    operators.takeWhile((valueConfig) => {
+      if (!("complete" in valueConfig)) {
+        return true;
+      }
+      if (valueConfig.complete) {
+        onCompleteSubject.next();
+        return false;
+      }
+      return true;
+    }),
+    operators.concatMap((valueConfig) => {
+      if ("value" in valueConfig && valueConfig.value) {
+        if (valueConfig.delay) {
+          return rxjs.of(valueConfig.value).pipe(operators.delay(valueConfig.delay));
+        }
+        return rxjs.of(valueConfig.value);
+      }
+      if ("errorValue" in valueConfig && valueConfig.errorValue) {
+        if (valueConfig.delay) {
+          return rxjs.timer(valueConfig.delay).pipe(operators.switchMap(() => rxjs.throwError(() => valueConfig.errorValue)));
+        }
+        return rxjs.throwError(() => valueConfig.errorValue);
+      }
+      return rxjs.EMPTY;
+    })
+  );
+  return rxjs.merge(results$, subject.pipe(operators.takeUntil(onCompleteSubject)));
+}
+function addObservableHelpers(objectToDecorate, providedSubject, onSubjectConfigured) {
+  objectToDecorate.nextWith = (value) => {
+    providedSubject.next(value);
+    onSubjectConfigured(providedSubject);
+  };
+  objectToDecorate.nextOneTimeWith = (value) => {
+    providedSubject.next(value);
+    providedSubject.complete();
+    onSubjectConfigured(providedSubject);
+  };
+  objectToDecorate.nextWithValues = (valuesConfigs) => {
+    if (valuesConfigs.length === 0) {
+      return;
+    }
+    onSubjectConfigured(mergeSubjectWithDefaultValues(providedSubject, valuesConfigs));
+  };
+  objectToDecorate.throwWith = (value) => {
+    providedSubject.error(value);
+    onSubjectConfigured(providedSubject);
+  };
+  objectToDecorate.complete = () => {
+    providedSubject.complete();
+    onSubjectConfigured(providedSubject);
+  };
+  objectToDecorate.returnSubject = () => {
+    onSubjectConfigured(providedSubject);
+    return providedSubject;
+  };
+}
+function addNextWithPerCall(objectToDecorate, returnValueContainer, onConfigured = () => void 0) {
+  objectToDecorate.nextWithPerCall = (valueConfigsPerCall) => {
+    const returnedSubjects = [];
+    if (valueConfigsPerCall.length === 0) {
+      return returnedSubjects;
+    }
+    returnValueContainer.valuesPerCalls = [];
+    valueConfigsPerCall.forEach((valueConfiguration) => {
+      const replaySubject = new rxjs.ReplaySubject(1);
+      replaySubject.next(valueConfiguration.value);
+      returnedSubjects.push(replaySubject);
+      let returnedObservable = replaySubject.asObservable();
+      if (valueConfiguration.delay) {
+        returnedObservable = returnedObservable.pipe(operators.delay(valueConfiguration.delay));
+      }
+      if (!valueConfiguration.doNotComplete) {
+        returnedObservable = returnedObservable.pipe(operators.take(1));
+      }
+      returnValueContainer.valuesPerCalls.push({ wrappedValue: returnedObservable });
+    });
+    onConfigured(returnValueContainer);
+    return returnedSubjects;
+  };
+}
+function addObservableHelpersToFunctionSpy(spyFunction, valueContainer) {
+  const subject = createReplaySubject();
+  addObservableHelpers(spyFunction, subject, (configuredSubject) => {
+    valueContainer.value = configuredSubject;
+  });
+  addNextWithPerCall(spyFunction, valueContainer);
+}
+function addObservableHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
+  const subject = createReplaySubject();
+  const returnValueContainer = { value: void 0 };
+  addObservableHelpers(calledWithObject, subject, (configuredSubject) => {
+    returnValueContainer.value = configuredSubject;
+    calledWithObject.argsToValuesMap.set(calledWithArgs, returnValueContainer);
+  });
+  addNextWithPerCall(calledWithObject, returnValueContainer, (configured) => {
+    calledWithObject.argsToValuesMap.set(calledWithArgs, configured);
+  });
+}
+function createObservableWithValues(valuesConfigs, config) {
+  const subject = createReplaySubject();
+  const values$ = mergeSubjectWithDefaultValues(subject, valuesConfigs);
+  if (config && config.returnSubject) {
+    return { values$, subject };
+  }
+  return values$;
+}
+function createObservablePropSpy() {
+  let subject = createReplaySubject();
+  const observableSpy = rxjs.defer(() => subject);
+  addObservableHelpers(observableSpy, subject, (configuredSubject) => {
+    subject = configuredSubject;
+  });
+  return observableSpy;
+}
+function addPromiseHelpersToFunctionSpy(spyFunction, valueContainer) {
+  spyFunction.resolveWith = (value) => {
+    valueContainer.value = Promise.resolve(value);
+  };
+  spyFunction.rejectWith = (value) => {
+    valueContainer.value = value;
+    valueContainer._isRejectedPromise = true;
+  };
+  spyFunction.resolveWithPerCall = (valueConfigsPerCall) => {
+    if (valueConfigsPerCall.length === 0) {
+      return;
+    }
+    valueContainer.valuesPerCalls = [];
+    valueConfigsPerCall.forEach((valueConfiguration) => {
+      valueContainer.valuesPerCalls.push({
+        wrappedValue: Promise.resolve(valueConfiguration.value),
+        delay: valueConfiguration.delay
+      });
+    });
+  };
+}
+function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
+  calledWithObject.resolveWith = (value) => {
+    calledWithObject.argsToValuesMap.set(calledWithArgs, { value: Promise.resolve(value) });
+  };
+  calledWithObject.rejectWith = (value) => {
+    calledWithObject.argsToValuesMap.set(calledWithArgs, { value, _isRejectedPromise: true });
+  };
+  calledWithObject.resolveWithPerCall = (valueConfigsPerCall) => {
+    if (valueConfigsPerCall.length === 0) {
+      return;
+    }
+    const valueContainer = { value: void 0, valuesPerCalls: [] };
+    valueConfigsPerCall.forEach((valueConfiguration) => {
+      valueContainer.valuesPerCalls.push({
+        wrappedValue: Promise.resolve(valueConfiguration.value),
+        delay: valueConfiguration.delay
+      });
+    });
+    calledWithObject.argsToValuesMap.set(calledWithArgs, valueContainer);
+  };
+}
+function getNextCallValue(valueContainer) {
+  const wrapped = valueContainer.valuesPerCalls.shift();
+  let returnedValue = wrapped?.wrappedValue;
+  if (wrapped && wrapped.delay) {
+    returnedValue = returnedValue.then(
+      (value) => new Promise((resolve) => setTimeout(() => resolve(value), wrapped.delay))
+    );
+  }
+  return returnedValue;
+}
+function returnTheCorrectFakeValue(calledWithObject, mustBeCalledWithObject, valueContainer, actualArgs, functionName) {
+  if (calledWithObject.wasConfigured) {
+    const configured = calledWithObject.argsToValuesMap.get(actualArgs);
+    if (configured) {
+      return unwrapContainer(configured);
+    }
+  }
+  if (mustBeCalledWithObject.wasConfigured) {
+    const configured = mustBeCalledWithObject.argsToValuesMap.get(actualArgs);
+    if (configured) {
+      return unwrapContainer(configured);
+    }
+    errorHandler.throwArgumentsError(actualArgs, functionName);
+  }
+  return unwrapContainer(valueContainer);
+}
+function unwrapContainer(container) {
+  if (container._isRejectedPromise) {
+    return Promise.reject(container.value);
+  }
+  if (container.valuesPerCalls?.length) {
+    return getNextCallValue(container);
+  }
+  return container.value;
+}
+function addMethodsToCalledWith(calledWith, calledWithArgs) {
+  calledWith.wasConfigured = true;
+  calledWith.mockReturnValue = (value) => {
+    calledWith.argsToValuesMap.set(calledWithArgs, { value });
+  };
+  addPromiseHelpersToCalledWithObject(calledWith, calledWithArgs);
+  addObservableHelpersToCalledWithObject(calledWith, calledWithArgs);
+  return calledWith;
+}
+function createFunctionSpy(name) {
+  const calledWithObject = { wasConfigured: false, argsToValuesMap: new ArgsMap() };
+  const mustBeCalledWithObject = { wasConfigured: false, argsToValuesMap: new ArgsMap() };
+  const valueContainer = { value: void 0 };
+  const functionSpy = vitest.vi.fn(
+    (...actualArgs) => returnTheCorrectFakeValue(calledWithObject, mustBeCalledWithObject, valueContainer, actualArgs, name)
+  );
+  functionSpy.mockName(name);
+  addPromiseHelpersToFunctionSpy(functionSpy, valueContainer);
+  addObservableHelpersToFunctionSpy(functionSpy, valueContainer);
+  functionSpy.calledWith = (...calledWithArgs) => addMethodsToCalledWith(calledWithObject, calledWithArgs);
+  functionSpy.mustBeCalledWith = (...calledWithArgs) => addMethodsToCalledWith(mustBeCalledWithObject, calledWithArgs);
+  return functionSpy;
+}
+function defineWithEmptyAccessors(obj, prop) {
+  Object.defineProperty(obj, prop, {
+    get() {
+      return void 0;
+    },
+    set(_value) {
+    },
+    configurable: true
+  });
+}
+function accessorSpyFactory(autoSpy, accessorName, accessorType) {
+  if (accessorType === "setter") {
+    return vitest.vi.spyOn(autoSpy, accessorName, "set");
+  }
+  return vitest.vi.spyOn(autoSpy, accessorName, "get");
+}
+function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn) {
+  autoSpy.accessorSpies = { getters: {}, setters: {} };
+  gettersToSpyOn.forEach((getterName) => {
+    defineWithEmptyAccessors(autoSpy, getterName);
+    autoSpy.accessorSpies.getters[getterName] = accessorSpyFactory(autoSpy, getterName, "getter");
+  });
+  settersToSpyOn.forEach((setterName) => {
+    if (!Object.prototype.hasOwnProperty.call(autoSpy, setterName)) {
+      defineWithEmptyAccessors(autoSpy, setterName);
+    }
+    autoSpy.accessorSpies.setters[setterName] = accessorSpyFactory(autoSpy, setterName, "setter");
+  });
+}
+function extractMethodsFromObject(obj) {
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  return Object.keys(descriptors).reduce((names, name) => {
+    if (name !== "constructor" && !descriptors[name].get) {
+      names.push(name);
+    }
+    return names;
+  }, []);
+}
+function getAllMethodNames(obj) {
+  let methods = [];
+  while (obj) {
+    const parentObj = Object.getPrototypeOf(obj);
+    if (parentObj) {
+      methods = methods.concat(extractMethodsFromObject(obj));
+    }
+    obj = parentObj;
+  }
+  return methods;
+}
+function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
+  const methodNames = getAllMethodNames(ObjectClass.prototype);
+  let methodsToSpyOn = [];
+  let observablePropsToSpyOn = [];
+  let settersToSpyOn = [];
+  let gettersToSpyOn = [];
+  if (methodsToSpyOnOrConfig) {
+    if (Array.isArray(methodsToSpyOnOrConfig)) {
+      methodsToSpyOn = methodsToSpyOnOrConfig;
+    } else {
+      methodsToSpyOn = methodsToSpyOnOrConfig.methodsToSpyOn || [];
+      observablePropsToSpyOn = methodsToSpyOnOrConfig.observablePropsToSpyOn || [];
+      settersToSpyOn = methodsToSpyOnOrConfig.settersToSpyOn || [];
+      gettersToSpyOn = methodsToSpyOnOrConfig.gettersToSpyOn || [];
+    }
+  }
+  if (methodsToSpyOn.length > 0) {
+    methodNames.push(...methodsToSpyOn);
+  }
+  const autoSpy = {};
+  observablePropsToSpyOn.forEach((observablePropName) => {
+    autoSpy[observablePropName] = createObservablePropSpy();
+  });
+  createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn);
+  methodNames.forEach((methodName) => {
+    autoSpy[methodName] = createFunctionSpy(methodName);
+  });
+  return autoSpy;
+}
+function provideAutoSpy(ObjectClass, methodsToSpyOnOrConfig) {
+  return {
+    provide: ObjectClass,
+    useValue: createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig)
+  };
+}
+function injectSpy(token) {
+  return testing.TestBed.inject(token);
+}
+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) {
+  Object.defineProperty(object, property, { get: vitest.vi.fn(), set: vitest.vi.fn(), configurable: true });
+}
+
+exports.createFunctionSpy = createFunctionSpy;
+exports.createObservableWithValues = createObservableWithValues;
+exports.createSpyFromClass = createSpyFromClass;
+exports.errorHandler = errorHandler;
+exports.injectSpy = injectSpy;
+exports.mockAccessorsProp = mockAccessorsProp;
+exports.mockReadonlyProp = mockReadonlyProp;
+exports.mockReadonlyPropGetter = mockReadonlyPropGetter;
+exports.provideAutoSpy = provideAutoSpy;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map