.

qwen/nodejs/node_modules/jest-mock/build/index.d.ts

@@ -0,0 +1,406 @@
+/**
+ * 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.
+ */
+export declare type ClassLike = {
+  new (...args: any): any;
+};
+
+export declare type ConstructorLikeKeys<T> = keyof {
+  [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
+};
+
+export declare const fn: <T extends FunctionLike = UnknownFunction>(
+  implementation?: T | undefined,
+) => Mock<T>;
+
+export declare type FunctionLike = (...args: any) => any;
+
+export declare type MethodLikeKeys<T> = keyof {
+  [K in keyof T as Required<T>[K] extends FunctionLike ? K : never]: T[K];
+};
+
+/**
+ * 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.
+ */
+export declare interface Mock<T extends FunctionLike = UnknownFunction>
+  extends Function,
+    MockInstance<T> {
+  new (...args: Parameters<T>): ReturnType<T>;
+  (...args: Parameters<T>): ReturnType<T>;
+}
+
+export declare type Mocked<T> = T extends ClassLike
+  ? MockedClass<T>
+  : T extends FunctionLike
+  ? MockedFunction<T>
+  : T extends object
+  ? MockedObject<T>
+  : T;
+
+export declare const mocked: {
+  <T extends object>(
+    source: T,
+    options?: {
+      shallow: false;
+    },
+  ): Mocked<T>;
+  <T_1 extends object>(
+    source: T_1,
+    options: {
+      shallow: true;
+    },
+  ): MockedShallow<T_1>;
+};
+
+export declare type MockedClass<T extends ClassLike> = MockInstance<
+  (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
+> &
+  MockedObject<T>;
+
+export declare type MockedFunction<T extends FunctionLike> = MockInstance<T> &
+  MockedObject<T>;
+
+declare type MockedFunctionShallow<T extends FunctionLike> = MockInstance<T> &
+  T;
+
+export declare type MockedObject<T extends object> = {
+  [K in keyof T]: T[K] extends ClassLike
+    ? MockedClass<T[K]>
+    : T[K] extends FunctionLike
+    ? MockedFunction<T[K]>
+    : T[K] extends object
+    ? MockedObject<T[K]>
+    : T[K];
+} & T;
+
+declare type MockedObjectShallow<T extends object> = {
+  [K in keyof T]: T[K] extends ClassLike
+    ? MockedClass<T[K]>
+    : T[K] extends FunctionLike
+    ? MockedFunctionShallow<T[K]>
+    : T[K];
+} & T;
+
+export declare type MockedShallow<T> = T extends ClassLike
+  ? MockedClass<T>
+  : T extends FunctionLike
+  ? MockedFunctionShallow<T>
+  : T extends object
+  ? MockedObjectShallow<T>
+  : T;
+
+export declare type MockFunctionMetadata<
+  T = unknown,
+  MetadataType = MockMetadataType,
+> = MockMetadata<T, MetadataType>;
+
+export declare type MockFunctionMetadataType = MockMetadataType;
+
+declare type MockFunctionResult<T extends FunctionLike = UnknownFunction> =
+  | MockFunctionResultIncomplete
+  | MockFunctionResultReturn<T>
+  | MockFunctionResultThrow;
+
+declare type MockFunctionResultIncomplete = {
+  type: 'incomplete';
+  /**
+   * Result of a single call to a mock function that has not yet completed.
+   * This occurs if you test the result from within the mock function itself,
+   * or from within a function that was called by the mock.
+   */
+  value: undefined;
+};
+
+declare type MockFunctionResultReturn<
+  T extends FunctionLike = UnknownFunction,
+> = {
+  type: 'return';
+  /**
+   * Result of a single call to a mock function that returned.
+   */
+  value: ReturnType<T>;
+};
+
+declare type MockFunctionResultThrow = {
+  type: 'throw';
+  /**
+   * Result of a single call to a mock function that threw.
+   */
+  value: unknown;
+};
+
+declare type MockFunctionState<T extends FunctionLike = UnknownFunction> = {
+  /**
+   * List of the call arguments of all calls that have been made to the mock.
+   */
+  calls: Array<Parameters<T>>;
+  /**
+   * List of all the object instances that have been instantiated from the mock.
+   */
+  instances: Array<ReturnType<T>>;
+  /**
+   * List of all the function contexts that have been applied to calls to the mock.
+   */
+  contexts: Array<ThisParameterType<T>>;
+  /**
+   * List of the call order indexes of the mock. Jest is indexing the order of
+   * invocations of all mocks in a test file. The index is starting with `1`.
+   */
+  invocationCallOrder: Array<number>;
+  /**
+   * List of the call arguments of the last call that was made to the mock.
+   * If the function was not called, it will return `undefined`.
+   */
+  lastCall?: Parameters<T>;
+  /**
+   * List of the results of all calls that have been made to the mock.
+   */
+  results: Array<MockFunctionResult<T>>;
+};
+
+export declare interface MockInstance<
+  T extends FunctionLike = UnknownFunction,
+> {
+  _isMockFunction: true;
+  _protoImpl: Function;
+  getMockImplementation(): T | undefined;
+  getMockName(): string;
+  mock: MockFunctionState<T>;
+  mockClear(): this;
+  mockReset(): this;
+  mockRestore(): void;
+  mockImplementation(fn: T): this;
+  mockImplementationOnce(fn: T): this;
+  withImplementation(fn: T, callback: () => Promise<unknown>): Promise<void>;
+  withImplementation(fn: T, callback: () => void): void;
+  mockName(name: string): this;
+  mockReturnThis(): this;
+  mockReturnValue(value: ReturnType<T>): this;
+  mockReturnValueOnce(value: ReturnType<T>): this;
+  mockResolvedValue(value: ResolveType<T>): this;
+  mockResolvedValueOnce(value: ResolveType<T>): this;
+  mockRejectedValue(value: RejectType<T>): this;
+  mockRejectedValueOnce(value: RejectType<T>): this;
+}
+
+export declare type MockMetadata<T, MetadataType = MockMetadataType> = {
+  ref?: number;
+  members?: Record<string, MockMetadata<T>>;
+  mockImpl?: T;
+  name?: string;
+  refID?: number;
+  type?: MetadataType;
+  value?: T;
+  length?: number;
+};
+
+export declare type MockMetadataType =
+  | 'object'
+  | 'array'
+  | 'regexp'
+  | 'function'
+  | 'constant'
+  | 'collection'
+  | 'null'
+  | 'undefined';
+
+export declare class ModuleMocker {
+  private readonly _environmentGlobal;
+  private _mockState;
+  private _mockConfigRegistry;
+  private _spyState;
+  private _invocationCallCounter;
+  /**
+   * @see README.md
+   * @param global Global object of the test environment, used to create
+   * mocks
+   */
+  constructor(global: typeof globalThis);
+  private _getSlots;
+  private _ensureMockConfig;
+  private _ensureMockState;
+  private _defaultMockConfig;
+  private _defaultMockState;
+  private _makeComponent;
+  private _createMockFunction;
+  private _generateMock;
+  /**
+   * Check whether the given property of an object has been already replaced.
+   */
+  private _findReplacedProperty;
+  /**
+   * @see README.md
+   * @param metadata Metadata for the mock in the schema returned by the
+   * getMetadata method of this module.
+   */
+  generateFromMetadata<T>(metadata: MockMetadata<T>): Mocked<T>;
+  /**
+   * @see README.md
+   * @param component The component for which to retrieve metadata.
+   */
+  getMetadata<T = unknown>(
+    component: T,
+    _refs?: Map<T, number>,
+  ): MockMetadata<T> | null;
+  isMockFunction<T extends FunctionLike = UnknownFunction>(
+    fn: MockInstance<T>,
+  ): fn is MockInstance<T>;
+  isMockFunction<P extends Array<unknown>, R>(
+    fn: (...args: P) => R,
+  ): fn is Mock<(...args: P) => R>;
+  isMockFunction(fn: unknown): fn is Mock<UnknownFunction>;
+  fn<T extends FunctionLike = UnknownFunction>(implementation?: T): Mock<T>;
+  spyOn<
+    T extends object,
+    K extends PropertyLikeKeys<T>,
+    V extends Required<T>[K],
+    A extends 'get' | 'set',
+  >(
+    object: T,
+    methodKey: K,
+    accessType: A,
+  ): A extends 'get'
+    ? SpiedGetter<V>
+    : A extends 'set'
+    ? SpiedSetter<V>
+    : never;
+  spyOn<
+    T extends object,
+    K extends ConstructorLikeKeys<T> | MethodLikeKeys<T>,
+    V extends Required<T>[K],
+  >(
+    object: T,
+    methodKey: K,
+  ): V extends ClassLike | FunctionLike ? Spied<V> : never;
+  private _spyOnProperty;
+  replaceProperty<T extends object, K extends keyof T>(
+    object: T,
+    propertyKey: K,
+    value: T[K],
+  ): Replaced<T[K]>;
+  clearAllMocks(): void;
+  resetAllMocks(): void;
+  restoreAllMocks(): void;
+  private _typeOf;
+  mocked<T extends object>(
+    source: T,
+    options?: {
+      shallow: false;
+    },
+  ): Mocked<T>;
+  mocked<T extends object>(
+    source: T,
+    options: {
+      shallow: true;
+    },
+  ): MockedShallow<T>;
+}
+
+export declare type PropertyLikeKeys<T> = Exclude<
+  keyof T,
+  ConstructorLikeKeys<T> | MethodLikeKeys<T>
+>;
+
+declare type RejectType<T extends FunctionLike> =
+  ReturnType<T> extends PromiseLike<any> ? unknown : never;
+
+export declare interface Replaced<T = unknown> {
+  /**
+   * Restore property to its original value known at the time of mocking.
+   */
+  restore(): void;
+  /**
+   * Change the value of the property.
+   */
+  replaceValue(value: T): this;
+}
+
+export declare const replaceProperty: <T extends object, K extends keyof T>(
+  object: T,
+  propertyKey: K,
+  value: T[K],
+) => Replaced<T[K]>;
+
+declare type ResolveType<T extends FunctionLike> =
+  ReturnType<T> extends PromiseLike<infer U> ? U : never;
+
+export declare type Spied<T extends ClassLike | FunctionLike> =
+  T extends ClassLike
+    ? SpiedClass<T>
+    : T extends FunctionLike
+    ? SpiedFunction<T>
+    : never;
+
+export declare type SpiedClass<T extends ClassLike = UnknownClass> =
+  MockInstance<(...args: ConstructorParameters<T>) => InstanceType<T>>;
+
+export declare type SpiedFunction<T extends FunctionLike = UnknownFunction> =
+  MockInstance<(...args: Parameters<T>) => ReturnType<T>>;
+
+export declare type SpiedGetter<T> = MockInstance<() => T>;
+
+export declare type SpiedSetter<T> = MockInstance<(arg: T) => void>;
+
+export declare interface SpyInstance<T extends FunctionLike = UnknownFunction>
+  extends MockInstance<T> {}
+
+export declare const spyOn: {
+  <
+    T extends object,
+    K_2 extends Exclude<
+      keyof T,
+      | keyof {
+          [K in keyof T as Required<T>[K] extends ClassLike ? K : never]: T[K];
+        }
+      | keyof {
+          [K_1 in keyof T as Required<T>[K_1] extends FunctionLike
+            ? K_1
+            : never]: T[K_1];
+        }
+    >,
+    V extends Required<T>[K_2],
+    A extends 'set' | 'get',
+  >(
+    object: T,
+    methodKey: K_2,
+    accessType: A,
+  ): A extends 'get'
+    ? SpiedGetter<V>
+    : A extends 'set'
+    ? SpiedSetter<V>
+    : never;
+  <
+    T_1 extends object,
+    K_5 extends
+      | keyof {
+          [K_3 in keyof T_1 as Required<T_1>[K_3] extends ClassLike
+            ? K_3
+            : never]: T_1[K_3];
+        }
+      | keyof {
+          [K_4 in keyof T_1 as Required<T_1>[K_4] extends FunctionLike
+            ? K_4
+            : never]: T_1[K_4];
+        },
+    V_1 extends Required<T_1>[K_5],
+  >(
+    object: T_1,
+    methodKey: K_5,
+  ): V_1 extends ClassLike | FunctionLike ? Spied<V_1> : never;
+};
+
+export declare type UnknownClass = {
+  new (...args: Array<unknown>): unknown;
+};
+
+export declare type UnknownFunction = (...args: Array<unknown>) => unknown;
+
+export {};