????
Your IP : 216.73.216.131
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.spyOn =
exports.replaceProperty =
exports.mocked =
exports.fn =
exports.ModuleMocker =
void 0;
function _jestUtil() {
const data = require('jest-util');
_jestUtil = function () {
return data;
};
return data;
}
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/* eslint-disable local/ban-types-eventually, local/prefer-rest-params-eventually */
// TODO remove re-export in Jest 30
// TODO remove re-export in Jest 30
// TODO in Jest 30 remove `SpyInstance` in favour of `Spied`
// eslint-disable-next-line @typescript-eslint/no-empty-interface
/**
* All what the internal typings need is to be sure that we have any-function.
* `FunctionLike` type ensures that and helps to constrain the type as well.
* The default of `UnknownFunction` makes sure that `any`s do not leak to the
* user side. For instance, calling `fn()` without implementation will return
* a mock of `(...args: Array<unknown>) => unknown` type. If implementation
* is provided, its typings are inferred correctly.
*/
const MOCK_CONSTRUCTOR_NAME = 'mockConstructor';
const FUNCTION_NAME_RESERVED_PATTERN = /[\s!-/:-@[-`{-~]/;
const FUNCTION_NAME_RESERVED_REPLACE = new RegExp(
FUNCTION_NAME_RESERVED_PATTERN.source,
'g'
);
const RESERVED_KEYWORDS = new Set([
'arguments',
'await',
'break',
'case',
'catch',
'class',
'const',
'continue',
'debugger',
'default',
'delete',
'do',
'else',
'enum',
'eval',
'export',
'extends',
'false',
'finally',
'for',
'function',
'if',
'implements',
'import',
'in',
'instanceof',
'interface',
'let',
'new',
'null',
'package',
'private',
'protected',
'public',
'return',
'static',
'super',
'switch',
'this',
'throw',
'true',
'try',
'typeof',
'var',
'void',
'while',
'with',
'yield'
]);
function matchArity(fn, length) {
let mockConstructor;
switch (length) {
case 1:
mockConstructor = function (_a) {
return fn.apply(this, arguments);
};
break;
case 2:
mockConstructor = function (_a, _b) {
return fn.apply(this, arguments);
};
break;
case 3:
mockConstructor = function (_a, _b, _c) {
return fn.apply(this, arguments);
};
break;
case 4:
mockConstructor = function (_a, _b, _c, _d) {
return fn.apply(this, arguments);
};
break;
case 5:
mockConstructor = function (_a, _b, _c, _d, _e) {
return fn.apply(this, arguments);
};
break;
case 6:
mockConstructor = function (_a, _b, _c, _d, _e, _f) {
return fn.apply(this, arguments);
};
break;
case 7:
mockConstructor = function (_a, _b, _c, _d, _e, _f, _g) {
return fn.apply(this, arguments);
};
break;
case 8:
mockConstructor = function (_a, _b, _c, _d, _e, _f, _g, _h) {
return fn.apply(this, arguments);
};
break;
case 9:
mockConstructor = function (_a, _b, _c, _d, _e, _f, _g, _h, _i) {
return fn.apply(this, arguments);
};
break;
default:
mockConstructor = function () {
return fn.apply(this, arguments);
};
break;
}
return mockConstructor;
}
function getObjectType(value) {
return Object.prototype.toString.apply(value).slice(8, -1);
}
function getType(ref) {
const typeName = getObjectType(ref);
if (
typeName === 'Function' ||
typeName === 'AsyncFunction' ||
typeName === 'GeneratorFunction' ||
typeName === 'AsyncGeneratorFunction'
) {
return 'function';
} else if (Array.isArray(ref)) {
return 'array';
} else if (typeName === 'Object' || typeName === 'Module') {
return 'object';
} else if (
typeName === 'Number' ||
typeName === 'String' ||
typeName === 'Boolean' ||
typeName === 'Symbol'
) {
return 'constant';
} else if (
typeName === 'Map' ||
typeName === 'WeakMap' ||
typeName === 'Set'
) {
return 'collection';
} else if (typeName === 'RegExp') {
return 'regexp';
} else if (ref === undefined) {
return 'undefined';
} else if (ref === null) {
return 'null';
} else {
return null;
}
}
function isReadonlyProp(object, prop) {
if (
prop === 'arguments' ||
prop === 'caller' ||
prop === 'callee' ||
prop === 'name' ||
prop === 'length'
) {
const typeName = getObjectType(object);
return (
typeName === 'Function' ||
typeName === 'AsyncFunction' ||
typeName === 'GeneratorFunction' ||
typeName === 'AsyncGeneratorFunction'
);
}
if (
prop === 'source' ||
prop === 'global' ||
prop === 'ignoreCase' ||
prop === 'multiline'
) {
return getObjectType(object) === 'RegExp';
}
return false;
}
class ModuleMocker {
_environmentGlobal;
_mockState;
_mockConfigRegistry;
_spyState;
_invocationCallCounter;
/**
* @see README.md
* @param global Global object of the test environment, used to create
* mocks
*/
constructor(global) {
this._environmentGlobal = global;
this._mockState = new WeakMap();
this._mockConfigRegistry = new WeakMap();
this._spyState = new Set();
this._invocationCallCounter = 1;
}
_getSlots(object) {
if (!object) {
return [];
}
const slots = new Set();
const EnvObjectProto = this._environmentGlobal.Object.prototype;
const EnvFunctionProto = this._environmentGlobal.Function.prototype;
const EnvRegExpProto = this._environmentGlobal.RegExp.prototype;
// Also check the builtins in the current context as they leak through
// core node modules.
const ObjectProto = Object.prototype;
const FunctionProto = Function.prototype;
const RegExpProto = RegExp.prototype;
// Properties of Object.prototype, Function.prototype and RegExp.prototype
// are never reported as slots
while (
object != null &&
object !== EnvObjectProto &&
object !== EnvFunctionProto &&
object !== EnvRegExpProto &&
object !== ObjectProto &&
object !== FunctionProto &&
object !== RegExpProto
) {
const ownNames = Object.getOwnPropertyNames(object);
for (let i = 0; i < ownNames.length; i++) {
const prop = ownNames[i];
if (!isReadonlyProp(object, prop)) {
const propDesc = Object.getOwnPropertyDescriptor(object, prop);
if ((propDesc !== undefined && !propDesc.get) || object.__esModule) {
slots.add(prop);
}
}
}
object = Object.getPrototypeOf(object);
}
return Array.from(slots);
}
_ensureMockConfig(f) {
let config = this._mockConfigRegistry.get(f);
if (!config) {
config = this._defaultMockConfig();
this._mockConfigRegistry.set(f, config);
}
return config;
}
_ensureMockState(f) {
let state = this._mockState.get(f);
if (!state) {
state = this._defaultMockState();
this._mockState.set(f, state);
}
if (state.calls.length > 0) {
state.lastCall = state.calls[state.calls.length - 1];
}
return state;
}
_defaultMockConfig() {
return {
mockImpl: undefined,
mockName: 'jest.fn()',
specificMockImpls: []
};
}
_defaultMockState() {
return {
calls: [],
contexts: [],
instances: [],
invocationCallOrder: [],
results: []
};
}
_makeComponent(metadata, restore) {
if (metadata.type === 'object') {
return new this._environmentGlobal.Object();
} else if (metadata.type === 'array') {
return new this._environmentGlobal.Array();
} else if (metadata.type === 'regexp') {
return new this._environmentGlobal.RegExp('');
} else if (
metadata.type === 'constant' ||
metadata.type === 'collection' ||
metadata.type === 'null' ||
metadata.type === 'undefined'
) {
return metadata.value;
} else if (metadata.type === 'function') {
const prototype =
(metadata.members &&
metadata.members.prototype &&
metadata.members.prototype.members) ||
{};
const prototypeSlots = this._getSlots(prototype);
// eslint-disable-next-line @typescript-eslint/no-this-alias
const mocker = this;
const mockConstructor = matchArity(function (...args) {
const mockState = mocker._ensureMockState(f);
const mockConfig = mocker._ensureMockConfig(f);
mockState.instances.push(this);
mockState.contexts.push(this);
mockState.calls.push(args);
// Create and record an "incomplete" mock result immediately upon
// calling rather than waiting for the mock to return. This avoids
// issues caused by recursion where results can be recorded in the
// wrong order.
const mockResult = {
type: 'incomplete',
value: undefined
};
mockState.results.push(mockResult);
mockState.invocationCallOrder.push(mocker._invocationCallCounter++);
// Will be set to the return value of the mock if an error is not thrown
let finalReturnValue;
// Will be set to the error that is thrown by the mock (if it throws)
let thrownError;
// Will be set to true if the mock throws an error. The presence of a
// value in `thrownError` is not a 100% reliable indicator because a
// function could throw a value of undefined.
let callDidThrowError = false;
try {
// The bulk of the implementation is wrapped in an immediately
// executed arrow function so the return value of the mock function
// can be easily captured and recorded, despite the many separate
// return points within the logic.
finalReturnValue = (() => {
if (this instanceof f) {
// This is probably being called as a constructor
prototypeSlots.forEach(slot => {
// Copy prototype methods to the instance to make
// it easier to interact with mock instance call and
// return values
if (prototype[slot].type === 'function') {
// @ts-expect-error no index signature
const protoImpl = this[slot];
// @ts-expect-error no index signature
this[slot] = mocker.generateFromMetadata(prototype[slot]);
// @ts-expect-error no index signature
this[slot]._protoImpl = protoImpl;
}
});
// Run the mock constructor implementation
const mockImpl = mockConfig.specificMockImpls.length
? mockConfig.specificMockImpls.shift()
: mockConfig.mockImpl;
return mockImpl && mockImpl.apply(this, arguments);
}
// If mockImplementationOnce()/mockImplementation() is last set,
// implementation use the mock
let specificMockImpl = mockConfig.specificMockImpls.shift();
if (specificMockImpl === undefined) {
specificMockImpl = mockConfig.mockImpl;
}
if (specificMockImpl) {
return specificMockImpl.apply(this, arguments);
}
// Otherwise use prototype implementation
if (f._protoImpl) {
return f._protoImpl.apply(this, arguments);
}
return undefined;
})();
} catch (error) {
// Store the thrown error so we can record it, then re-throw it.
thrownError = error;
callDidThrowError = true;
throw error;
} finally {
// Record the result of the function.
// NOTE: Intentionally NOT pushing/indexing into the array of mock
// results here to avoid corrupting results data if mockClear()
// is called during the execution of the mock.
// @ts-expect-error reassigning 'incomplete'
mockResult.type = callDidThrowError ? 'throw' : 'return';
mockResult.value = callDidThrowError ? thrownError : finalReturnValue;
}
return finalReturnValue;
}, metadata.length || 0);
const f = this._createMockFunction(metadata, mockConstructor);
f._isMockFunction = true;
f.getMockImplementation = () => this._ensureMockConfig(f).mockImpl;
if (typeof restore === 'function') {
this._spyState.add(restore);
}
this._mockState.set(f, this._defaultMockState());
this._mockConfigRegistry.set(f, this._defaultMockConfig());
Object.defineProperty(f, 'mock', {
configurable: false,
enumerable: true,
get: () => this._ensureMockState(f),
set: val => this._mockState.set(f, val)
});
f.mockClear = () => {
this._mockState.delete(f);
return f;
};
f.mockReset = () => {
f.mockClear();
this._mockConfigRegistry.delete(f);
return f;
};
f.mockRestore = () => {
f.mockReset();
return restore ? restore() : undefined;
};
f.mockReturnValueOnce = value =>
// next function call will return this value or default return value
f.mockImplementationOnce(() => value);
f.mockResolvedValueOnce = value =>
f.mockImplementationOnce(() =>
this._environmentGlobal.Promise.resolve(value)
);
f.mockRejectedValueOnce = value =>
f.mockImplementationOnce(() =>
this._environmentGlobal.Promise.reject(value)
);
f.mockReturnValue = value =>
// next function call will return specified return value or this one
f.mockImplementation(() => value);
f.mockResolvedValue = value =>
f.mockImplementation(() =>
this._environmentGlobal.Promise.resolve(value)
);
f.mockRejectedValue = value =>
f.mockImplementation(() =>
this._environmentGlobal.Promise.reject(value)
);
f.mockImplementationOnce = fn => {
// next function call will use this mock implementation return value
// or default mock implementation return value
const mockConfig = this._ensureMockConfig(f);
mockConfig.specificMockImpls.push(fn);
return f;
};
f.withImplementation = withImplementation.bind(this);
function withImplementation(fn, callback) {
// Remember previous mock implementation, then set new one
const mockConfig = this._ensureMockConfig(f);
const previousImplementation = mockConfig.mockImpl;
const previousSpecificImplementations = mockConfig.specificMockImpls;
mockConfig.mockImpl = fn;
mockConfig.specificMockImpls = [];
const returnedValue = callback();
if ((0, _jestUtil().isPromise)(returnedValue)) {
return returnedValue.then(() => {
mockConfig.mockImpl = previousImplementation;
mockConfig.specificMockImpls = previousSpecificImplementations;
});
} else {
mockConfig.mockImpl = previousImplementation;
mockConfig.specificMockImpls = previousSpecificImplementations;
}
}
f.mockImplementation = fn => {
// next function call will use mock implementation return value
const mockConfig = this._ensureMockConfig(f);
mockConfig.mockImpl = fn;
return f;
};
f.mockReturnThis = () =>
f.mockImplementation(function () {
return this;
});
f.mockName = name => {
if (name) {
const mockConfig = this._ensureMockConfig(f);
mockConfig.mockName = name;
}
return f;
};
f.getMockName = () => {
const mockConfig = this._ensureMockConfig(f);
return mockConfig.mockName || 'jest.fn()';
};
if (metadata.mockImpl) {
f.mockImplementation(metadata.mockImpl);
}
return f;
} else {
const unknownType = metadata.type || 'undefined type';
throw new Error(`Unrecognized type ${unknownType}`);
}
}
_createMockFunction(metadata, mockConstructor) {
let name = metadata.name;
if (!name) {
return mockConstructor;
}
// Preserve `name` property of mocked function.
const boundFunctionPrefix = 'bound ';
let bindCall = '';
// if-do-while for perf reasons. The common case is for the if to fail.
if (name.startsWith(boundFunctionPrefix)) {
do {
name = name.substring(boundFunctionPrefix.length);
// Call bind() just to alter the function name.
bindCall = '.bind(null)';
} while (name && name.startsWith(boundFunctionPrefix));
}
// Special case functions named `mockConstructor` to guard for infinite loops
if (name === MOCK_CONSTRUCTOR_NAME) {
return mockConstructor;
}
if (
// It's a syntax error to define functions with a reserved keyword as name
RESERVED_KEYWORDS.has(name) ||
// It's also a syntax error to define functions with a name that starts with a number
/^\d/.test(name)
) {
name = `$${name}`;
}
// It's also a syntax error to define a function with a reserved character
// as part of it's name.
if (FUNCTION_NAME_RESERVED_PATTERN.test(name)) {
name = name.replace(FUNCTION_NAME_RESERVED_REPLACE, '$');
}
const body =
`return function ${name}() {` +
` return ${MOCK_CONSTRUCTOR_NAME}.apply(this,arguments);` +
`}${bindCall}`;
const createConstructor = new this._environmentGlobal.Function(
MOCK_CONSTRUCTOR_NAME,
body
);
return createConstructor(mockConstructor);
}
_generateMock(metadata, callbacks, refs) {
// metadata not compatible but it's the same type, maybe problem with
// overloading of _makeComponent and not _generateMock?
// @ts-expect-error - unsure why TSC complains here?
const mock = this._makeComponent(metadata);
if (metadata.refID != null) {
refs[metadata.refID] = mock;
}
this._getSlots(metadata.members).forEach(slot => {
const slotMetadata = (metadata.members && metadata.members[slot]) || {};
if (slotMetadata.ref != null) {
callbacks.push(
(function (ref) {
return () => (mock[slot] = refs[ref]);
})(slotMetadata.ref)
);
} else {
mock[slot] = this._generateMock(slotMetadata, callbacks, refs);
}
});
if (
metadata.type !== 'undefined' &&
metadata.type !== 'null' &&
mock.prototype &&
typeof mock.prototype === 'object'
) {
mock.prototype.constructor = mock;
}
return mock;
}
/**
* Check whether the given property of an object has been already replaced.
*/
_findReplacedProperty(object, propertyKey) {
for (const spyState of this._spyState) {
if (
'object' in spyState &&
'property' in spyState &&
spyState.object === object &&
spyState.property === propertyKey
) {
return spyState;
}
}
return;
}
/**
* @see README.md
* @param metadata Metadata for the mock in the schema returned by the
* getMetadata method of this module.
*/
generateFromMetadata(metadata) {
const callbacks = [];
const refs = {};
const mock = this._generateMock(metadata, callbacks, refs);
callbacks.forEach(setter => setter());
return mock;
}
/**
* @see README.md
* @param component The component for which to retrieve metadata.
*/
getMetadata(component, _refs) {
const refs = _refs || new Map();
const ref = refs.get(component);
if (ref != null) {
return {
ref
};
}
const type = getType(component);
if (!type) {
return null;
}
const metadata = {
type
};
if (
type === 'constant' ||
type === 'collection' ||
type === 'undefined' ||
type === 'null'
) {
metadata.value = component;
return metadata;
} else if (type === 'function') {
// @ts-expect-error component is a function so it has a name, but not
// necessarily a string: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#function_names_in_classes
const componentName = component.name;
if (typeof componentName === 'string') {
metadata.name = componentName;
}
if (this.isMockFunction(component)) {
metadata.mockImpl = component.getMockImplementation();
}
}
metadata.refID = refs.size;
refs.set(component, metadata.refID);
let members = null;
// Leave arrays alone
if (type !== 'array') {
// @ts-expect-error component is object
this._getSlots(component).forEach(slot => {
if (
type === 'function' &&
this.isMockFunction(component) &&
slot.match(/^mock/)
) {
return;
}
// @ts-expect-error no index signature
const slotMetadata = this.getMetadata(component[slot], refs);
if (slotMetadata) {
if (!members) {
members = {};
}
members[slot] = slotMetadata;
}
});
}
if (members) {
metadata.members = members;
}
return metadata;
}
isMockFunction(fn) {
return fn != null && fn._isMockFunction === true;
}
fn(implementation) {
const length = implementation ? implementation.length : 0;
const fn = this._makeComponent({
length,
type: 'function'
});
if (implementation) {
fn.mockImplementation(implementation);
}
return fn;
}
spyOn(object, methodKey, accessType) {
if (
object == null ||
(typeof object !== 'object' && typeof object !== 'function')
) {
throw new Error(
`Cannot use spyOn on a primitive value; ${this._typeOf(object)} given`
);
}
if (methodKey == null) {
throw new Error('No property name supplied');
}
if (accessType) {
return this._spyOnProperty(object, methodKey, accessType);
}
const original = object[methodKey];
if (!original) {
throw new Error(
`Property \`${String(
methodKey
)}\` does not exist in the provided object`
);
}
if (!this.isMockFunction(original)) {
if (typeof original !== 'function') {
throw new Error(
`Cannot spy on the \`${String(
methodKey
)}\` property because it is not a function; ${this._typeOf(
original
)} given instead.${
typeof original !== 'object'
? ` If you are trying to mock a property, use \`jest.replaceProperty(object, '${String(
methodKey
)}', value)\` instead.`
: ''
}`
);
}
const isMethodOwner = Object.prototype.hasOwnProperty.call(
object,
methodKey
);
let descriptor = Object.getOwnPropertyDescriptor(object, methodKey);
let proto = Object.getPrototypeOf(object);
while (!descriptor && proto !== null) {
descriptor = Object.getOwnPropertyDescriptor(proto, methodKey);
proto = Object.getPrototypeOf(proto);
}
let mock;
if (descriptor && descriptor.get) {
const originalGet = descriptor.get;
mock = this._makeComponent(
{
type: 'function'
},
() => {
descriptor.get = originalGet;
Object.defineProperty(object, methodKey, descriptor);
}
);
descriptor.get = () => mock;
Object.defineProperty(object, methodKey, descriptor);
} else {
mock = this._makeComponent(
{
type: 'function'
},
() => {
if (isMethodOwner) {
object[methodKey] = original;
} else {
delete object[methodKey];
}
}
);
// @ts-expect-error overriding original method with a Mock
object[methodKey] = mock;
}
mock.mockImplementation(function () {
return original.apply(this, arguments);
});
}
return object[methodKey];
}
_spyOnProperty(object, propertyKey, accessType) {
let descriptor = Object.getOwnPropertyDescriptor(object, propertyKey);
let proto = Object.getPrototypeOf(object);
while (!descriptor && proto !== null) {
descriptor = Object.getOwnPropertyDescriptor(proto, propertyKey);
proto = Object.getPrototypeOf(proto);
}
if (!descriptor) {
throw new Error(
`Property \`${String(
propertyKey
)}\` does not exist in the provided object`
);
}
if (!descriptor.configurable) {
throw new Error(
`Property \`${String(propertyKey)}\` is not declared configurable`
);
}
if (!descriptor[accessType]) {
throw new Error(
`Property \`${String(
propertyKey
)}\` does not have access type ${accessType}`
);
}
const original = descriptor[accessType];
if (!this.isMockFunction(original)) {
if (typeof original !== 'function') {
throw new Error(
`Cannot spy on the ${String(
propertyKey
)} property because it is not a function; ${this._typeOf(
original
)} given instead.${
typeof original !== 'object'
? ` If you are trying to mock a property, use \`jest.replaceProperty(object, '${String(
propertyKey
)}', value)\` instead.`
: ''
}`
);
}
descriptor[accessType] = this._makeComponent(
{
type: 'function'
},
() => {
// @ts-expect-error: mock is assignable
descriptor[accessType] = original;
Object.defineProperty(object, propertyKey, descriptor);
}
);
descriptor[accessType].mockImplementation(function () {
// @ts-expect-error - wrong context
return original.apply(this, arguments);
});
}
Object.defineProperty(object, propertyKey, descriptor);
return descriptor[accessType];
}
replaceProperty(object, propertyKey, value) {
if (
object == null ||
(typeof object !== 'object' && typeof object !== 'function')
) {
throw new Error(
`Cannot use replaceProperty on a primitive value; ${this._typeOf(
object
)} given`
);
}
if (propertyKey == null) {
throw new Error('No property name supplied');
}
let descriptor = Object.getOwnPropertyDescriptor(object, propertyKey);
let proto = Object.getPrototypeOf(object);
while (!descriptor && proto !== null) {
descriptor = Object.getOwnPropertyDescriptor(proto, propertyKey);
proto = Object.getPrototypeOf(proto);
}
if (!descriptor) {
throw new Error(
`Property \`${String(
propertyKey
)}\` does not exist in the provided object`
);
}
if (!descriptor.configurable) {
throw new Error(
`Property \`${String(propertyKey)}\` is not declared configurable`
);
}
if (descriptor.get !== undefined) {
throw new Error(
`Cannot replace the \`${String(
propertyKey
)}\` property because it has a getter. Use \`jest.spyOn(object, '${String(
propertyKey
)}', 'get').mockReturnValue(value)\` instead.`
);
}
if (descriptor.set !== undefined) {
throw new Error(
`Cannot replace the \`${String(
propertyKey
)}\` property because it has a setter. Use \`jest.spyOn(object, '${String(
propertyKey
)}', 'set').mockReturnValue(value)\` instead.`
);
}
if (typeof descriptor.value === 'function') {
throw new Error(
`Cannot replace the \`${String(
propertyKey
)}\` property because it is a function. Use \`jest.spyOn(object, '${String(
propertyKey
)}')\` instead.`
);
}
const existingRestore = this._findReplacedProperty(object, propertyKey);
if (existingRestore) {
return existingRestore.replaced.replaceValue(value);
}
const isPropertyOwner = Object.prototype.hasOwnProperty.call(
object,
propertyKey
);
const originalValue = descriptor.value;
const restore = () => {
if (isPropertyOwner) {
object[propertyKey] = originalValue;
} else {
delete object[propertyKey];
}
};
const replaced = {
replaceValue: value => {
object[propertyKey] = value;
return replaced;
},
restore: () => {
restore();
this._spyState.delete(restore);
}
};
restore.object = object;
restore.property = propertyKey;
restore.replaced = replaced;
this._spyState.add(restore);
return replaced.replaceValue(value);
}
clearAllMocks() {
this._mockState = new WeakMap();
}
resetAllMocks() {
this._mockConfigRegistry = new WeakMap();
this._mockState = new WeakMap();
}
restoreAllMocks() {
this._spyState.forEach(restore => restore());
this._spyState = new Set();
}
_typeOf(value) {
return value == null ? `${value}` : typeof value;
}
mocked(source, _options) {
return source;
}
}
exports.ModuleMocker = ModuleMocker;
const JestMock = new ModuleMocker(globalThis);
const fn = JestMock.fn.bind(JestMock);
exports.fn = fn;
const spyOn = JestMock.spyOn.bind(JestMock);
exports.spyOn = spyOn;
const mocked = JestMock.mocked.bind(JestMock);
exports.mocked = mocked;
const replaceProperty = JestMock.replaceProperty.bind(JestMock);
exports.replaceProperty = replaceProperty;