{"version":3,"file":"index.cjs","sources":["../src/Matchers.ts","../src/CalledWithFn.ts","../src/Mock.ts"],"sourcesContent":["type MatcherFn<T> = (actualValue: T) => boolean\n\ninterface MatcherLike<_> {\n  asymmetricMatch(other: unknown): boolean\n  toString(): string\n  getExpectedType?(): string\n  toAsymmetricMatcher?(): string\n}\n\n// needs to be a class so we can instanceof\nclass Matcher<T> implements MatcherLike<T> {\n  $$typeof: symbol\n  inverse?: boolean\n\n  constructor(\n    readonly asymmetricMatch: MatcherFn<T>,\n    private readonly description: string\n  ) {\n    this.$$typeof = Symbol.for('vi.asymmetricMatcher')\n  }\n\n  toString() {\n    return this.description\n  }\n\n  toAsymmetricMatcher() {\n    return this.description\n  }\n\n  getExpectedType() {\n    return 'undefined'\n  }\n}\n\nclass CaptorMatcher<T> {\n  $$typeof: symbol\n  public readonly asymmetricMatch: MatcherFn<T>\n  public readonly value!: T\n  public readonly values: T[] = []\n  constructor() {\n    this.$$typeof = Symbol.for('vi.asymmetricMatcher')\n\n    this.asymmetricMatch = (actualValue: T) => {\n      // @ts-expect-error value should be read-only but we need to set it\n      this.value = actualValue\n      this.values.push(actualValue)\n      return true\n    }\n  }\n\n  getExpectedType() {\n    return 'Object'\n  }\n\n  toString() {\n    return 'captor'\n  }\n\n  toAsymmetricMatcher() {\n    return 'captor'\n  }\n}\n\ntype MatcherCreator<T, E = T> = (expectedValue?: E) => Matcher<T>\n\ntype MatchersOrLiterals<Y extends unknown[]> = { [K in keyof Y]: MatcherLike<Y[K]> | Y[K] }\n\nconst any: MatcherCreator<unknown> = () => new Matcher(() => true, 'any()')\nconst anyBoolean: MatcherCreator<boolean> = () =>\n  new Matcher((actualValue: boolean) => typeof actualValue === 'boolean', 'anyBoolean()')\nconst anyNumber: MatcherCreator<number> = () =>\n  new Matcher((actualValue) => typeof actualValue === 'number' && !Number.isNaN(actualValue), 'anyNumber()')\nconst anyString: MatcherCreator<string> = () =>\n  new Matcher((actualValue: string) => typeof actualValue === 'string', 'anyString()')\nconst anyFunction: MatcherCreator<CallableFunction> = () =>\n  new Matcher((actualValue: CallableFunction) => typeof actualValue === 'function', 'anyFunction()')\nconst anySymbol: MatcherCreator<symbol> = () =>\n  new Matcher((actualValue) => typeof actualValue === 'symbol', 'anySymbol()')\nconst anyObject: MatcherCreator<unknown> = () =>\n  new Matcher((actualValue) => typeof actualValue === 'object' && actualValue !== null, 'anyObject()')\n\nconst anyArray: MatcherCreator<unknown[]> = () => new Matcher((actualValue) => Array.isArray(actualValue), 'anyArray()')\nconst anyMap: MatcherCreator<Map<unknown, unknown>> = () =>\n  new Matcher((actualValue) => actualValue instanceof Map, 'anyMap()')\nconst anySet: MatcherCreator<Set<unknown>> = () => new Matcher((actualValue) => actualValue instanceof Set, 'anySet()')\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any class, not just ones that extend a specific base class.\nconst isA: MatcherCreator<any> = (clazz) => new Matcher((actualValue) => actualValue instanceof clazz, 'isA()')\n\nconst arrayIncludes: MatcherCreator<unknown[], unknown> = (arrayVal) =>\n  new Matcher((actualValue) => Array.isArray(actualValue) && actualValue.includes(arrayVal), 'arrayIncludes()')\nconst setHas: MatcherCreator<Set<unknown>, unknown> = (arrayVal) =>\n  new Matcher((actualValue) => anySet().asymmetricMatch(actualValue) && actualValue.has(arrayVal), 'setHas()')\nconst mapHas: MatcherCreator<Map<unknown, unknown>, unknown> = (mapVal) =>\n  new Matcher((actualValue) => anyMap().asymmetricMatch(actualValue) && actualValue.has(mapVal), 'mapHas()')\nconst objectContainsKey: MatcherCreator<Record<string, unknown>, string> = (key) =>\n  new Matcher(\n    // biome-ignore lint/style/noNonNullAssertion: We know key is defined since it's a parameter, but the type definition for asymmetricMatch requires us to check it at runtime.\n    (actualValue) => anyObject().asymmetricMatch(actualValue) && actualValue[key!] !== undefined,\n    'objectContainsKey()'\n  )\nconst objectContainsValue: MatcherCreator<Record<string, unknown> | ArrayLike<unknown>> = (value) =>\n  new Matcher(\n    (actualValue) => anyObject().asymmetricMatch(actualValue) && Object.values(actualValue).includes(value),\n    'objectContainsValue()'\n  )\n\nconst notNull: MatcherCreator<unknown> = () => new Matcher((actualValue) => actualValue !== null, 'notNull()')\nconst notUndefined: MatcherCreator<unknown> = () =>\n  new Matcher((actualValue) => actualValue !== undefined, 'notUndefined()')\nconst notEmpty: MatcherCreator<unknown> = () =>\n  new Matcher((actualValue) => actualValue !== null && actualValue !== undefined && actualValue !== '', 'notEmpty()')\n\nconst captor = <T>() => new CaptorMatcher<T>()\nconst matches = <T>(matcher: MatcherFn<T>) => new Matcher(matcher, 'matches()')\n\nexport type { MatcherCreator, MatcherFn, MatcherLike, MatchersOrLiterals }\nexport {\n  any,\n  anyArray,\n  anyBoolean,\n  anyFunction,\n  anyMap,\n  anyNumber,\n  anyObject,\n  anySet,\n  anyString,\n  anySymbol,\n  arrayIncludes,\n  CaptorMatcher,\n  captor,\n  isA,\n  Matcher,\n  mapHas,\n  matches,\n  notEmpty,\n  notNull,\n  notUndefined,\n  objectContainsKey,\n  objectContainsValue,\n  setHas,\n}\n","import { type Mock, vi } from 'vitest'\nimport { Matcher, type MatchersOrLiterals } from './Matchers'\nimport type { CalledWithMock } from './Mock'\nimport type { CalledWithImplementation, FallbackImplementation } from './types'\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\ninterface CalledWithStackItem<T, Y extends any[]> {\n  args: MatchersOrLiterals<Y>\n  calledWithFn: Mock<FallbackImplementation<Y, T>>\n}\n\ninterface VitestAsymmetricMatcher {\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  asymmetricMatch(...args: any[]): boolean\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nfunction isVitestAsymmetricMatcher(obj: any): obj is VitestAsymmetricMatcher {\n  return !!obj && typeof obj === 'object' && 'asymmetricMatch' in obj && typeof obj.asymmetricMatch === 'function'\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nconst checkCalledWith = <T, Y extends any[]>(\n  calledWithStack: CalledWithStackItem<T, Y>[],\n  actualArgs: Y,\n  fallbackMockImplementation?: FallbackImplementation<Y, T>\n): T | undefined => {\n  const calledWithInstance = calledWithStack.find((instance) =>\n    instance.args.every((matcher, i) => {\n      if (matcher instanceof Matcher) {\n        return matcher.asymmetricMatch(actualArgs[i])\n      }\n\n      if (isVitestAsymmetricMatcher(matcher)) {\n        return matcher.asymmetricMatch(actualArgs[i])\n      }\n\n      return actualArgs[i] === matcher\n    })\n  )\n\n  return calledWithInstance\n    ? calledWithInstance.calledWithFn(...actualArgs)\n    : fallbackMockImplementation?.(...actualArgs)\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\ntype CalledWithFnArgs<Y extends any[], T> = { fallbackMockImplementation?: FallbackImplementation<Y, T> }\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nconst calledWithFn = <T, Y extends any[]>({\n  fallbackMockImplementation,\n}: CalledWithFnArgs<Y, T> = {}): CalledWithMock<T, Y> => {\n  const fn: Mock<CalledWithImplementation<Y, T>> = fallbackMockImplementation\n    ? vi.fn(fallbackMockImplementation)\n    : vi.fn()\n  let calledWithStack: CalledWithStackItem<T, Y>[] = []\n\n  ;(fn as CalledWithMock<T, Y>).calledWith = (...args) => {\n    // We create new function to delegate any interactions (mockReturnValue etc.) to for this set of args.\n    // If that set of args is matched, we just call that vi.fn() for the result.\n    const calledWithFn: Mock<FallbackImplementation<Y, T>> = fallbackMockImplementation\n      ? vi.fn(fallbackMockImplementation)\n      : vi.fn()\n    const mockImplementation = fn.getMockImplementation()\n    if (\n      !mockImplementation ||\n      fn.getMockImplementation()?.name === 'implementation' ||\n      mockImplementation === fallbackMockImplementation\n    ) {\n      // Our original function gets a mock implementation which handles the matching\n      fn.mockImplementation((...args: Y) => checkCalledWith(calledWithStack, args, fallbackMockImplementation))\n      calledWithStack = []\n    }\n    calledWithStack.unshift({ args, calledWithFn })\n\n    return calledWithFn\n  }\n\n  return fn as CalledWithMock<T, Y>\n}\n\nexport { calledWithFn }\n","import type { DeepPartial } from 'ts-essentials'\nimport { type Mock, vi } from 'vitest'\nimport { calledWithFn } from './CalledWithFn'\nimport type { MatchersOrLiterals } from './Matchers'\nimport type { FallbackImplementation } from './types'\n\ntype ProxiedProperty = string | number | symbol\n\ninterface GlobalConfig {\n  // ignoreProps is required when we don't want to return anything for a mock (for example, when mocking a promise).\n  ignoreProps?: ProxiedProperty[]\n}\n\nconst DEFAULT_CONFIG: GlobalConfig = {\n  ignoreProps: ['then'],\n}\n\nlet GLOBAL_CONFIG = DEFAULT_CONFIG\n\nconst VitestMockExtended = {\n  DEFAULT_CONFIG,\n  configure: (config: GlobalConfig) => {\n    // Shallow merge so they can override anything they want.\n    GLOBAL_CONFIG = { ...DEFAULT_CONFIG, ...config }\n  },\n  resetConfig: () => {\n    GLOBAL_CONFIG = DEFAULT_CONFIG\n  },\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\ninterface CalledWithMock<T, Y extends any[]> extends Mock<FallbackImplementation<Y, T>> {\n  calledWith: (...args: Y | MatchersOrLiterals<Y>) => Mock<FallbackImplementation<Y, T>>\n}\n\ntype _MockProxy<T> = {\n  [K in keyof T]: T[K] extends (...args: infer A) => infer B ? T[K] & CalledWithMock<B, A> : T[K]\n}\n\ntype MockProxy<T> = _MockProxy<T> & T\n\ntype _DeepMockProxy<T> = {\n  // This supports deep mocks in the else branch\n  [K in keyof T]: T[K] extends (...args: infer A) => infer B ? T[K] & CalledWithMock<B, A> : T[K] & _DeepMockProxy<T[K]>\n}\n\n// we intersect with T here instead of on the mapped type above to\n// prevent immediate type resolution on a recursive type, this will\n// help to improve performance for deeply nested recursive mocking\n// at the same time, this intersection preserves private properties\ntype DeepMockProxy<T> = _DeepMockProxy<T> & T\n\ntype _DeepMockProxyWithFuncPropSupport<T> = {\n  // This supports deep mocks in the else branch\n  [K in keyof T]: T[K] extends (...args: infer A) => infer B\n    ? CalledWithMock<B, A> & DeepMockProxy<T[K]>\n    : DeepMockProxy<T[K]>\n}\n\ntype DeepMockProxyWithFuncPropSupport<T> = _DeepMockProxyWithFuncPropSupport<T> & T\n\ninterface MockOpts {\n  deep?: boolean\n  useActualToJSON?: boolean\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  fallbackMockImplementation?: (...args: any[]) => any\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nconst mockClear = (mock: MockProxy<any>) => {\n  for (const key of Object.keys(mock)) {\n    const value = mock[key]\n    if (value === null || value === undefined) {\n      continue\n    }\n\n    if (value._isMockObject) {\n      mockClear(value)\n    }\n\n    if (value._isMockFunction && 'mockClear' in value) {\n      value.mockClear()\n    }\n  }\n\n  // This is a catch for if they pass in a vi.fn()\n  if (!mock._isMockObject) {\n    return mock.mockClear()\n  }\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nconst mockReset = (mock: MockProxy<any>) => {\n  for (const key of Object.keys(mock)) {\n    if (mock[key] === null || mock[key] === undefined) {\n      continue\n    }\n\n    if (mock[key]._isMockObject) {\n      mockReset(mock[key])\n    }\n    if (mock[key]._isMockFunction) {\n      mock[key].mockReset()\n    }\n  }\n\n  // This is a catch for if they pass in a vi.fn()\n  // Worst case, we will create a vi.fn() (since this is a proxy)\n  // below in the get and call mockReset on it\n  if (!mock._isMockObject) {\n    return mock.mockReset()\n  }\n}\n\nfunction mockDeep<T>(\n  opts: {\n    funcPropSupport?: true\n    fallbackMockImplementation?: MockOpts['fallbackMockImplementation']\n  },\n  mockImplementation?: DeepPartial<T>\n): DeepMockProxyWithFuncPropSupport<T>\nfunction mockDeep<T>(mockImplementation?: DeepPartial<T>): DeepMockProxy<T>\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nfunction mockDeep(arg1: any, arg2?: any) {\n  const [opts, mockImplementation] =\n    typeof arg1 === 'object' && (typeof arg1.fallbackMockImplementation === 'function' || arg1.funcPropSupport === true)\n      ? [arg1, arg2]\n      : [{}, arg1]\n  return mock(mockImplementation, { deep: true, fallbackMockImplementation: opts.fallbackMockImplementation })\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\nconst overrideMockImp = (obj: DeepPartial<any>, opts?: MockOpts) => {\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  const proxy = new Proxy<MockProxy<any>>(obj, handler(opts))\n  for (const name of Object.keys(obj)) {\n    if (typeof obj[name] === 'object' && obj[name] !== null) {\n      proxy[name] = overrideMockImp(obj[name], opts)\n    } else {\n      proxy[name] = obj[name]\n    }\n  }\n\n  return proxy\n}\n\nconst handler = (opts?: MockOpts) => ({\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  ownKeys(target: MockProxy<any>) {\n    return Reflect.ownKeys(target)\n  },\n\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  set: (obj: MockProxy<any>, property: ProxiedProperty, value: any) => {\n    obj[property] = value\n    return true\n  },\n\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  get: (obj: MockProxy<any>, property: ProxiedProperty) => {\n    if (!(property in obj)) {\n      if (property === '_isMockObject' || property === '_isMockFunction') {\n        return undefined\n      }\n\n      if (GLOBAL_CONFIG.ignoreProps?.includes(property)) {\n        return undefined\n      }\n      // Jest's internal equality checking does some wierd stuff to check for iterable equality\n      if (property === Symbol.iterator) {\n        return obj[property]\n      }\n\n      if (opts?.useActualToJSON && property === 'toJSON') {\n        return JSON.stringify(obj)\n      }\n\n      // So this calls check here is totally not ideal - jest internally does a\n      // check to see if this is a spy - which we want to say no to, but blindly returning\n      // an proxy for calls results in the spy check returning true. This is another reason\n      // why deep is opt in.\n      const fn = calledWithFn({ fallbackMockImplementation: opts?.fallbackMockImplementation })\n      if (opts?.deep && property !== 'calls') {\n        // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n        obj[property] = new Proxy<MockProxy<any>>(fn, handler(opts))\n        obj[property]._isMockObject = true\n      } else {\n        obj[property] = fn\n      }\n    }\n\n    // @ts-expect-error expected type mismatch due to any\n    if (obj instanceof Date && typeof obj[property] === 'function') {\n      // @ts-expect-error expected type mismatch due to any\n      return obj[property].bind(obj)\n    }\n\n    return obj[property]\n  },\n})\n\nconst mock = <T, MockedReturn extends MockProxy<T> & T = MockProxy<T> & T>(\n  mockImplementation: DeepPartial<T> = {} as DeepPartial<T>,\n  opts?: MockOpts\n): MockedReturn => {\n  // @ts-expect-error private\n  // biome-ignore lint/style/noNonNullAssertion: We know this is defined since we set it on the object below, but the type definition for Proxy requires us to check it at runtime.\n  mockImplementation!._isMockObject = true\n  return overrideMockImp(mockImplementation, opts)\n}\n\nconst mockFn = <\n  T,\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  A extends any[] = T extends (...args: infer AReal) => any ? AReal : any[],\n  // biome-ignore lint/suspicious/noExplicitAny: This is necessary to support any matcher that has an asymmetricMatch function, not just our own Matcher class.\n  R = T extends (...args: any) => infer RReal ? RReal : any,\n>(): CalledWithMock<R, A> & T => {\n  // @ts-expect-error hard to get this type right using any\n  return calledWithFn()\n}\n\nfunction mocked<T>(obj: T, deep?: false): ReturnType<typeof mock<T>>\nfunction mocked<T>(obj: T, deep: true): ReturnType<typeof mockDeep<T>>\nfunction mocked<T>(obj: T, _deep?: boolean) {\n  return obj\n}\n\nfunction mockedFn<T>(obj: T) {\n  return obj as ReturnType<typeof mockFn<T>>\n}\n\nconst stub = <T extends object>(): T => {\n  return new Proxy<T>({} as T, {\n    get: (obj, property: ProxiedProperty) => {\n      if (property in obj) {\n        // @ts-expect-error expected\n        return obj[property]\n      }\n      return vi.fn()\n    },\n  })\n}\n\nexport type { CalledWithMock, DeepMockProxy, GlobalConfig, MockOpts, MockProxy }\nexport { mock, mockClear, mockDeep, mocked, mockedFn, mockFn, mockReset, stub, VitestMockExtended }\n"],"names":["vi","calledWithFn","args","mock"],"mappings":"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"}