jest-runtime/build/index.d.mts

import { CallerTransformOptions, ScriptTransformer, ShouldInstrumentOptions, shouldInstrument } from "@jest/transform";
import { IHasteMap, IModuleMap } from "jest-haste-map";
import Resolver from "jest-resolve";
import { JestEnvironment } from "@jest/environment";
import { expect } from "@jest/globals";
import { SourceMapRegistry } from "@jest/source-map";
import { TestContext, V8CoverageResult } from "@jest/test-result";
import { Config, Global } from "@jest/types";

//#region src/index.d.ts

interface JestGlobals extends Global.TestFrameworkGlobals {
  expect: typeof expect;
}
type HasteMapOptions = {
  console?: Console;
  maxWorkers: number;
  resetCache: boolean;
  watch?: boolean;
  watchman: boolean;
  workerThreads?: boolean;
};
interface InternalModuleOptions extends Required<CallerTransformOptions> {
  isInternalModule: boolean;
}
declare class Runtime {
  private readonly _cacheFS;
  private readonly _cacheFSBuffer;
  private readonly _config;
  private readonly _globalConfig;
  private readonly _coverageOptions;
  private _currentlyExecutingModulePath;
  private readonly _environment;
  private readonly _explicitShouldMock;
  private readonly _explicitShouldMockModule;
  private readonly _onGenerateMock;
  private _fakeTimersImplementation;
  private readonly _internalModuleRegistry;
  private _isCurrentlyExecutingManualMock;
  private _mainModule;
  private readonly _mockFactories;
  private readonly _mockMetaDataCache;
  private _mockRegistry;
  private _isolatedMockRegistry;
  private readonly _moduleMockRegistry;
  private readonly _moduleMockFactories;
  private readonly _moduleMocker;
  private _isolatedModuleRegistry;
  private _moduleRegistry;
  private readonly _esmoduleRegistry;
  private readonly _cjsNamedExports;
  private readonly _esmModuleLinkingMap;
  private readonly _testPath;
  private readonly _resolver;
  private _shouldAutoMock;
  private readonly _shouldMockModuleCache;
  private readonly _shouldUnmockTransitiveDependenciesCache;
  private readonly _sourceMapRegistry;
  private readonly _scriptTransformer;
  private readonly _fileTransforms;
  private readonly _fileTransformsMutex;
  private _v8CoverageInstrumenter;
  private _v8CoverageResult;
  private _v8CoverageSources;
  private readonly _transitiveShouldMock;
  private _unmockList;
  private readonly _virtualMocks;
  private readonly _virtualModuleMocks;
  private _moduleImplementation?;
  private readonly jestObjectCaches;
  private jestGlobals?;
  private readonly esmConditions;
  private readonly cjsConditions;
  private isTornDown;
  private isInsideTestCode;
  constructor(config: Config.ProjectConfig, environment: JestEnvironment, resolver: Resolver, transformer: ScriptTransformer, cacheFS: Map<string, string>, coverageOptions: ShouldInstrumentOptions, testPath: string, globalConfig: Config.GlobalConfig);
  static shouldInstrument: typeof shouldInstrument;
  static createContext(config: Config.ProjectConfig, options: {
    console?: Console;
    maxWorkers: number;
    watch?: boolean;
    watchman: boolean;
  }): Promise<TestContext>;
  static createHasteMap(config: Config.ProjectConfig, options?: HasteMapOptions): Promise<IHasteMap>;
  static createResolver(config: Config.ProjectConfig, moduleMap: IModuleMap): Resolver;
  unstable_shouldLoadAsEsm(modulePath: string): boolean;
  private loadEsmModule;
  private resolveModule;
  private linkAndEvaluateModule;
  unstable_importModule(from: string, moduleName?: string): Promise<unknown | void>;
  private loadCjsAsEsm;
  private importMock;
  private getExportsOfCjs;
  requireModule<T = unknown>(from: string, moduleName?: string, options?: InternalModuleOptions, isRequireActual?: boolean): T;
  requireInternalModule<T = unknown>(from: string, to?: string): T;
  requireActual<T = unknown>(from: string, moduleName: string): T;
  requireMock<T = unknown>(from: string, moduleName: string): T;
  private _loadModule;
  private _getFullTransformationOptions;
  requireModuleOrMock<T = unknown>(from: string, moduleName: string): T;
  isolateModules(fn: () => void): void;
  isolateModulesAsync(fn: () => Promise<void>): Promise<void>;
  resetModules(): void;
  collectV8Coverage(): Promise<void>;
  stopCollectingV8Coverage(): Promise<void>;
  getAllCoverageInfoCopy(): JestEnvironment['global']['__coverage__'];
  getAllV8CoverageInfoCopy(): V8CoverageResult;
  getSourceMaps(): SourceMapRegistry;
  setMock(from: string, moduleName: string, mockFactory: () => unknown, options?: {
    virtual?: boolean;
  }): void;
  private setModuleMock;
  restoreAllMocks(): void;
  resetAllMocks(): void;
  clearAllMocks(): void;
  enterTestCode(): void;
  leaveTestCode(): void;
  teardown(): void;
  private _resolveCjsModule;
  private _resolveModule;
  private _requireResolve;
  private _requireResolvePaths;
  private _execModule;
  private transformFile;
  private transformFileAsync;
  private createScriptFromCode;
  private _requireCoreModule;
  private _importCoreModule;
  private _importWasmModule;
  private _getMockedNativeModule;
  private _generateMock;
  private _shouldMockCjs;
  private _shouldMockModule;
  private _createRequireImplementation;
  private _createJestObjectFor;
  private _logFormattedReferenceError;
  private constructInjectedModuleParameters;
  private handleExecutionError;
  private getGlobalsForCjs;
  private getGlobalsForEsm;
  private getGlobalsFromEnvironment;
  private readFileBuffer;
  private readFile;
  setGlobalsForRuntime(globals: JestGlobals): void;
}
//#endregion
export { Runtime as default };