diff options
Diffstat (limited to 'node_modules/jest-runtime/build/index.js')
| -rw-r--r-- | node_modules/jest-runtime/build/index.js | 2454 |
1 files changed, 2454 insertions, 0 deletions
diff --git a/node_modules/jest-runtime/build/index.js b/node_modules/jest-runtime/build/index.js new file mode 100644 index 0000000..dd185a2 --- /dev/null +++ b/node_modules/jest-runtime/build/index.js @@ -0,0 +1,2454 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function nativeModule() { + const data = _interopRequireWildcard(require('module')); + + nativeModule = function () { + return data; + }; + + return data; +} + +function path() { + const data = _interopRequireWildcard(require('path')); + + path = function () { + return data; + }; + + return data; +} + +function _url() { + const data = require('url'); + + _url = function () { + return data; + }; + + return data; +} + +function _vm() { + const data = require('vm'); + + _vm = function () { + return data; + }; + + return data; +} + +function _cjsModuleLexer() { + const data = require('cjs-module-lexer'); + + _cjsModuleLexer = function () { + return data; + }; + + return data; +} + +function _collectV8Coverage() { + const data = require('collect-v8-coverage'); + + _collectV8Coverage = function () { + return data; + }; + + return data; +} + +function _execa() { + const data = _interopRequireDefault(require('execa')); + + _execa = function () { + return data; + }; + + return data; +} + +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + + fs = function () { + return data; + }; + + return data; +} + +function _slash() { + const data = _interopRequireDefault(require('slash')); + + _slash = function () { + return data; + }; + + return data; +} + +function _stripBom() { + const data = _interopRequireDefault(require('strip-bom')); + + _stripBom = function () { + return data; + }; + + return data; +} + +function _transform() { + const data = require('@jest/transform'); + + _transform = function () { + return data; + }; + + return data; +} + +function _jestHasteMap() { + const data = _interopRequireDefault(require('jest-haste-map')); + + _jestHasteMap = function () { + return data; + }; + + return data; +} + +function _jestMessageUtil() { + const data = require('jest-message-util'); + + _jestMessageUtil = function () { + return data; + }; + + return data; +} + +function _jestRegexUtil() { + const data = require('jest-regex-util'); + + _jestRegexUtil = function () { + return data; + }; + + return data; +} + +function _jestResolve() { + const data = _interopRequireDefault(require('jest-resolve')); + + _jestResolve = function () { + return data; + }; + + return data; +} + +function _jestSnapshot() { + const data = _interopRequireDefault(require('jest-snapshot')); + + _jestSnapshot = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +var _helpers = require('./helpers'); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} + +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +const esmIsAvailable = typeof _vm().SourceTextModule === 'function'; +const defaultTransformOptions = { + isInternalModule: false, + supportsDynamicImport: esmIsAvailable, + supportsExportNamespaceFrom: false, + supportsStaticESM: false, + supportsTopLevelAwait: false +}; +// These are modules that we know +// * are safe to require from the outside (not stateful, not prone to errors passing in instances from different realms), and +// * take sufficiently long to require to warrant an optimization. +// When required from the outside, they use the worker's require cache and are thus +// only loaded once per worker, not once per test file. +// Use /benchmarks/test-file-overhead to measure the impact. +// Note that this only applies when they are required in an internal context; +// users who require one of these modules in their tests will still get the module from inside the VM. +// Prefer listing a module here only if it is impractical to use the jest-resolve-outside-vm-option where it is required, +// e.g. because there are many require sites spread across the dependency graph. +const INTERNAL_MODULE_REQUIRE_OUTSIDE_OPTIMIZED_MODULES = new Set(['chalk']); +const JEST_RESOLVE_OUTSIDE_VM_OPTION = Symbol.for( + 'jest-resolve-outside-vm-option' +); +const testTimeoutSymbol = Symbol.for('TEST_TIMEOUT_SYMBOL'); +const retryTimesSymbol = Symbol.for('RETRY_TIMES'); +const NODE_MODULES = path().sep + 'node_modules' + path().sep; + +const getModuleNameMapper = config => { + if ( + Array.isArray(config.moduleNameMapper) && + config.moduleNameMapper.length + ) { + return config.moduleNameMapper.map(([regex, moduleName]) => ({ + moduleName, + regex: new RegExp(regex) + })); + } + + return null; +}; + +const unmockRegExpCache = new WeakMap(); +const EVAL_RESULT_VARIABLE = 'Object.<anonymous>'; +const runtimeSupportsVmModules = typeof _vm().SyntheticModule === 'function'; + +const supportsTopLevelAwait = + runtimeSupportsVmModules && + (() => { + try { + // eslint-disable-next-line no-new + new (_vm().SourceTextModule)('await Promise.resolve()'); + return true; + } catch { + return false; + } + })(); + +const supportsNodeColonModulePrefixInRequire = (() => { + try { + require('node:fs'); + + return true; + } catch { + return false; + } +})(); + +const supportsNodeColonModulePrefixInImport = (() => { + const {stdout} = _execa().default.sync( + 'node', + [ + '--eval', + 'import("node:fs").then(() => console.log(true), () => console.log(false));' + ], + { + reject: false + } + ); + + return stdout === 'true'; +})(); + +class Runtime { + constructor( + config, + environment, + resolver, + transformer, + cacheFS, + coverageOptions, + testPath + ) { + var _this$_environment$ex, _this$_environment$ex2, _this$_environment; + + _defineProperty(this, '_cacheFS', void 0); + + _defineProperty(this, '_config', void 0); + + _defineProperty(this, '_coverageOptions', void 0); + + _defineProperty(this, '_currentlyExecutingModulePath', void 0); + + _defineProperty(this, '_environment', void 0); + + _defineProperty(this, '_explicitShouldMock', void 0); + + _defineProperty(this, '_explicitShouldMockModule', void 0); + + _defineProperty(this, '_fakeTimersImplementation', void 0); + + _defineProperty(this, '_internalModuleRegistry', void 0); + + _defineProperty(this, '_isCurrentlyExecutingManualMock', void 0); + + _defineProperty(this, '_mainModule', void 0); + + _defineProperty(this, '_mockFactories', void 0); + + _defineProperty(this, '_mockMetaDataCache', void 0); + + _defineProperty(this, '_mockRegistry', void 0); + + _defineProperty(this, '_isolatedMockRegistry', void 0); + + _defineProperty(this, '_moduleMockRegistry', void 0); + + _defineProperty(this, '_moduleMockFactories', void 0); + + _defineProperty(this, '_moduleMocker', void 0); + + _defineProperty(this, '_isolatedModuleRegistry', void 0); + + _defineProperty(this, '_moduleRegistry', void 0); + + _defineProperty(this, '_esmoduleRegistry', void 0); + + _defineProperty(this, '_cjsNamedExports', void 0); + + _defineProperty(this, '_esmModuleLinkingMap', void 0); + + _defineProperty(this, '_testPath', void 0); + + _defineProperty(this, '_resolver', void 0); + + _defineProperty(this, '_shouldAutoMock', void 0); + + _defineProperty(this, '_shouldMockModuleCache', void 0); + + _defineProperty(this, '_shouldUnmockTransitiveDependenciesCache', void 0); + + _defineProperty(this, '_sourceMapRegistry', void 0); + + _defineProperty(this, '_scriptTransformer', void 0); + + _defineProperty(this, '_fileTransforms', void 0); + + _defineProperty(this, '_fileTransformsMutex', void 0); + + _defineProperty(this, '_v8CoverageInstrumenter', void 0); + + _defineProperty(this, '_v8CoverageResult', void 0); + + _defineProperty(this, '_transitiveShouldMock', void 0); + + _defineProperty(this, '_unmockList', void 0); + + _defineProperty(this, '_virtualMocks', void 0); + + _defineProperty(this, '_virtualModuleMocks', void 0); + + _defineProperty(this, '_moduleImplementation', void 0); + + _defineProperty(this, 'jestObjectCaches', void 0); + + _defineProperty(this, 'jestGlobals', void 0); + + _defineProperty(this, 'esmConditions', void 0); + + _defineProperty(this, 'cjsConditions', void 0); + + _defineProperty(this, 'isTornDown', false); + + this._cacheFS = cacheFS; + this._config = config; + this._coverageOptions = coverageOptions; + this._currentlyExecutingModulePath = ''; + this._environment = environment; + this._explicitShouldMock = new Map(); + this._explicitShouldMockModule = new Map(); + this._internalModuleRegistry = new Map(); + this._isCurrentlyExecutingManualMock = null; + this._mainModule = null; + this._mockFactories = new Map(); + this._mockRegistry = new Map(); + this._moduleMockRegistry = new Map(); + this._moduleMockFactories = new Map(); + invariant( + this._environment.moduleMocker, + '`moduleMocker` must be set on an environment when created' + ); + this._moduleMocker = this._environment.moduleMocker; + this._isolatedModuleRegistry = null; + this._isolatedMockRegistry = null; + this._moduleRegistry = new Map(); + this._esmoduleRegistry = new Map(); + this._cjsNamedExports = new Map(); + this._esmModuleLinkingMap = new WeakMap(); + this._testPath = testPath; + this._resolver = resolver; + this._scriptTransformer = transformer; + this._shouldAutoMock = config.automock; + this._sourceMapRegistry = new Map(); + this._fileTransforms = new Map(); + this._fileTransformsMutex = new Map(); + this._virtualMocks = new Map(); + this._virtualModuleMocks = new Map(); + this.jestObjectCaches = new Map(); + this._mockMetaDataCache = new Map(); + this._shouldMockModuleCache = new Map(); + this._shouldUnmockTransitiveDependenciesCache = new Map(); + this._transitiveShouldMock = new Map(); + this._fakeTimersImplementation = + config.timers === 'legacy' + ? this._environment.fakeTimers + : this._environment.fakeTimersModern; + this._unmockList = unmockRegExpCache.get(config); + + if (!this._unmockList && config.unmockedModulePathPatterns) { + this._unmockList = new RegExp( + config.unmockedModulePathPatterns.join('|') + ); + unmockRegExpCache.set(config, this._unmockList); + } + + const envExportConditions = + (_this$_environment$ex = + (_this$_environment$ex2 = (_this$_environment = this._environment) + .exportConditions) === null || _this$_environment$ex2 === void 0 + ? void 0 + : _this$_environment$ex2.call(_this$_environment)) !== null && + _this$_environment$ex !== void 0 + ? _this$_environment$ex + : []; + this.esmConditions = Array.from( + new Set(['import', 'default', ...envExportConditions]) + ); + this.cjsConditions = Array.from( + new Set(['require', 'default', ...envExportConditions]) + ); + + if (config.automock) { + config.setupFiles.forEach(filePath => { + if (filePath.includes(NODE_MODULES)) { + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + filePath, + undefined, // shouldn't really matter, but in theory this will make sure the caching is correct + { + conditions: this.unstable_shouldLoadAsEsm(filePath) + ? this.esmConditions + : this.cjsConditions + } + ); + + this._transitiveShouldMock.set(moduleID, false); + } + }); + } + + this.resetModules(); + } + + static async createContext(config, options) { + (0, _jestUtil().createDirectory)(config.cacheDirectory); + const instance = Runtime.createHasteMap(config, { + console: options.console, + maxWorkers: options.maxWorkers, + resetCache: !config.cache, + watch: options.watch, + watchman: options.watchman + }); + const hasteMap = await instance.build(); + return { + config, + hasteFS: hasteMap.hasteFS, + moduleMap: hasteMap.moduleMap, + resolver: Runtime.createResolver(config, hasteMap.moduleMap) + }; + } + + static createHasteMap(config, options) { + const ignorePatternParts = [ + ...config.modulePathIgnorePatterns, + ...(options && options.watch ? config.watchPathIgnorePatterns : []), + config.cacheDirectory.startsWith(config.rootDir + path().sep) && + config.cacheDirectory + ].filter(Boolean); + const ignorePattern = + ignorePatternParts.length > 0 + ? new RegExp(ignorePatternParts.join('|')) + : undefined; + return _jestHasteMap().default.create({ + cacheDirectory: config.cacheDirectory, + computeSha1: config.haste.computeSha1, + console: + options === null || options === void 0 ? void 0 : options.console, + dependencyExtractor: config.dependencyExtractor, + enableSymlinks: config.haste.enableSymlinks, + extensions: [_jestSnapshot().default.EXTENSION].concat( + config.moduleFileExtensions + ), + forceNodeFilesystemAPI: config.haste.forceNodeFilesystemAPI, + hasteImplModulePath: config.haste.hasteImplModulePath, + hasteMapModulePath: config.haste.hasteMapModulePath, + ignorePattern, + maxWorkers: + (options === null || options === void 0 + ? void 0 + : options.maxWorkers) || 1, + mocksPattern: (0, _jestRegexUtil().escapePathForRegex)( + path().sep + '__mocks__' + path().sep + ), + name: config.name, + platforms: config.haste.platforms || ['ios', 'android'], + resetCache: + options === null || options === void 0 ? void 0 : options.resetCache, + retainAllFiles: false, + rootDir: config.rootDir, + roots: config.roots, + throwOnModuleCollision: config.haste.throwOnModuleCollision, + useWatchman: + options === null || options === void 0 ? void 0 : options.watchman, + watch: options === null || options === void 0 ? void 0 : options.watch + }); + } + + static createResolver(config, moduleMap) { + return new (_jestResolve().default)(moduleMap, { + defaultPlatform: config.haste.defaultPlatform, + extensions: config.moduleFileExtensions.map(extension => '.' + extension), + hasCoreModules: true, + moduleDirectories: config.moduleDirectories, + moduleNameMapper: getModuleNameMapper(config), + modulePaths: config.modulePaths, + platforms: config.haste.platforms, + resolver: config.resolver, + rootDir: config.rootDir + }); + } + + static async runCLI() { + throw new Error('The jest-runtime CLI has been moved into jest-repl'); + } + + static getCLIOptions() { + throw new Error('The jest-runtime CLI has been moved into jest-repl'); + } // unstable as it should be replaced by https://github.com/nodejs/modules/issues/393, and we don't want people to use it + + unstable_shouldLoadAsEsm(path) { + return _jestResolve().default.unstable_shouldLoadAsEsm( + path, + this._config.extensionsToTreatAsEsm + ); + } // not async _now_, but transform will be + + async loadEsmModule(modulePath, query = '') { + const cacheKey = modulePath + query; + + if (this._fileTransformsMutex.has(cacheKey)) { + await this._fileTransformsMutex.get(cacheKey); + } + + if (!this._esmoduleRegistry.has(cacheKey)) { + invariant( + typeof this._environment.getVmContext === 'function', + 'ES Modules are only supported if your test environment has the `getVmContext` function' + ); + + const context = this._environment.getVmContext(); + + invariant(context, 'Test environment has been torn down'); + let transformResolve; + let transformReject; + + this._fileTransformsMutex.set( + cacheKey, + new Promise((resolve, reject) => { + transformResolve = resolve; + transformReject = reject; + }) + ); + + invariant( + transformResolve && transformReject, + 'Promise initialization should be sync - please report this bug to Jest!' + ); + + if (this._resolver.isCoreModule(modulePath)) { + const core = this._importCoreModule(modulePath, context); + + this._esmoduleRegistry.set(cacheKey, core); + + transformResolve(); + return core; + } + + const transformedCode = await this.transformFileAsync(modulePath, { + isInternalModule: false, + supportsDynamicImport: true, + supportsExportNamespaceFrom: true, + supportsStaticESM: true, + supportsTopLevelAwait + }); + + try { + const module = new (_vm().SourceTextModule)(transformedCode, { + context, + identifier: modulePath, + importModuleDynamically: async (specifier, referencingModule) => { + invariant( + runtimeSupportsVmModules, + 'You need to run with a version of node that supports ES Modules in the VM API. See https://jestjs.io/docs/ecmascript-modules' + ); + const module = await this.resolveModule( + specifier, + referencingModule.identifier, + referencingModule.context + ); + return this.linkAndEvaluateModule(module); + }, + + initializeImportMeta(meta) { + meta.url = (0, _url().pathToFileURL)(modulePath).href; + } + }); + invariant( + !this._esmoduleRegistry.has(cacheKey), + `Module cache already has entry ${cacheKey}. This is a bug in Jest, please report it!` + ); + + this._esmoduleRegistry.set(cacheKey, module); + + transformResolve(); + } catch (error) { + transformReject(error); + throw error; + } + } + + const module = this._esmoduleRegistry.get(cacheKey); + + invariant( + module, + 'Module cache does not contain module. This is a bug in Jest, please open up an issue' + ); + return module; + } + + resolveModule(specifier, referencingIdentifier, context) { + if (this.isTornDown) { + this._logFormattedReferenceError( + 'You are trying to `import` a file after the Jest environment has been torn down.' + ); + + process.exitCode = 1; + return; + } + + if (specifier === '@jest/globals') { + const fromCache = this._esmoduleRegistry.get('@jest/globals'); + + if (fromCache) { + return fromCache; + } + + const globals = this.getGlobalsForEsm(referencingIdentifier, context); + + this._esmoduleRegistry.set('@jest/globals', globals); + + return globals; + } + + if (specifier.startsWith('file://')) { + specifier = (0, _url().fileURLToPath)(specifier); + } + + const [path, query] = specifier.split('?'); + + if ( + this._shouldMock( + referencingIdentifier, + path, + this._explicitShouldMockModule, + { + conditions: this.esmConditions + } + ) + ) { + return this.importMock(referencingIdentifier, path, context); + } + + const resolved = this._resolveModule(referencingIdentifier, path, { + conditions: this.esmConditions + }); + + if ( + this._resolver.isCoreModule(resolved) || + this.unstable_shouldLoadAsEsm(resolved) + ) { + return this.loadEsmModule(resolved, query); + } + + return this.loadCjsAsEsm(referencingIdentifier, resolved, context); + } + + async linkAndEvaluateModule(module) { + if (this.isTornDown) { + this._logFormattedReferenceError( + 'You are trying to `import` a file after the Jest environment has been torn down.' + ); + + process.exitCode = 1; + return; + } + + if (module.status === 'unlinked') { + // since we might attempt to link the same module in parallel, stick the promise in a weak map so every call to + // this method can await it + this._esmModuleLinkingMap.set( + module, + module.link((specifier, referencingModule) => + this.resolveModule( + specifier, + referencingModule.identifier, + referencingModule.context + ) + ) + ); + } + + await this._esmModuleLinkingMap.get(module); + + if (module.status === 'linked') { + await module.evaluate(); + } + + return module; + } + + async unstable_importModule(from, moduleName) { + invariant( + runtimeSupportsVmModules, + 'You need to run with a version of node that supports ES Modules in the VM API. See https://jestjs.io/docs/ecmascript-modules' + ); + const [path, query] = ( + moduleName !== null && moduleName !== void 0 ? moduleName : '' + ).split('?'); + + const modulePath = this._resolveModule(from, path, { + conditions: this.esmConditions + }); + + const module = await this.loadEsmModule(modulePath, query); + return this.linkAndEvaluateModule(module); + } + + loadCjsAsEsm(from, modulePath, context) { + // CJS loaded via `import` should share cache with other CJS: https://github.com/nodejs/modules/issues/503 + const cjs = this.requireModuleOrMock(from, modulePath); + const parsedExports = this.getExportsOfCjs(modulePath); + const cjsExports = [...parsedExports].filter(exportName => { + // we don't wanna respect any exports _named_ default as a named export + if (exportName === 'default') { + return false; + } + + return Object.hasOwnProperty.call(cjs, exportName); + }); + const module = new (_vm().SyntheticModule)( + [...cjsExports, 'default'], + function () { + cjsExports.forEach(exportName => { + // @ts-expect-error + this.setExport(exportName, cjs[exportName]); + }); // @ts-expect-error: TS doesn't know what `this` is + + this.setExport('default', cjs); + }, + { + context, + identifier: modulePath + } + ); + return evaluateSyntheticModule(module); + } + + async importMock(from, moduleName, context) { + const moduleID = this._resolver.getModuleID( + this._virtualModuleMocks, + from, + moduleName, + { + conditions: this.esmConditions + } + ); + + if (this._moduleMockRegistry.has(moduleID)) { + return this._moduleMockRegistry.get(moduleID); + } + + if (this._moduleMockFactories.has(moduleID)) { + const invokedFactory = await this._moduleMockFactories.get( + moduleID // has check above makes this ok + )(); + const module = new (_vm().SyntheticModule)( + Object.keys(invokedFactory), + function () { + Object.entries(invokedFactory).forEach(([key, value]) => { + // @ts-expect-error: TS doesn't know what `this` is + this.setExport(key, value); + }); + }, + { + context, + identifier: moduleName + } + ); + + this._moduleMockRegistry.set(moduleID, module); + + return evaluateSyntheticModule(module); + } + + throw new Error('Attempting to import a mock without a factory'); + } + + getExportsOfCjs(modulePath) { + var _this$_fileTransforms, _this$_fileTransforms2; + + const cachedNamedExports = this._cjsNamedExports.get(modulePath); + + if (cachedNamedExports) { + return cachedNamedExports; + } + + const transformedCode = + (_this$_fileTransforms = + (_this$_fileTransforms2 = this._fileTransforms.get(modulePath)) === + null || _this$_fileTransforms2 === void 0 + ? void 0 + : _this$_fileTransforms2.code) !== null && + _this$_fileTransforms !== void 0 + ? _this$_fileTransforms + : this.readFile(modulePath); + const {exports, reexports} = (0, _cjsModuleLexer().parse)(transformedCode); + const namedExports = new Set(exports); + reexports.forEach(reexport => { + const resolved = this._resolveModule(modulePath, reexport, { + conditions: this.esmConditions + }); + + const exports = this.getExportsOfCjs(resolved); + exports.forEach(namedExports.add, namedExports); + }); + + this._cjsNamedExports.set(modulePath, namedExports); + + return namedExports; + } + + requireModule(from, moduleName, options, isRequireActual = false) { + var _options$isInternalMo; + + const isInternal = + (_options$isInternalMo = + options === null || options === void 0 + ? void 0 + : options.isInternalModule) !== null && + _options$isInternalMo !== void 0 + ? _options$isInternalMo + : false; + + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + isInternal + ? undefined + : { + conditions: this.cjsConditions + } + ); + + let modulePath; // Some old tests rely on this mocking behavior. Ideally we'll change this + // to be more explicit. + + const moduleResource = moduleName && this._resolver.getModule(moduleName); + + const manualMock = + moduleName && this._resolver.getMockModule(from, moduleName); + + if ( + !(options !== null && options !== void 0 && options.isInternalModule) && + !isRequireActual && + !moduleResource && + manualMock && + manualMock !== this._isCurrentlyExecutingManualMock && + this._explicitShouldMock.get(moduleID) !== false + ) { + modulePath = manualMock; + } + + if (moduleName && this._resolver.isCoreModule(moduleName)) { + return this._requireCoreModule( + moduleName, + supportsNodeColonModulePrefixInRequire + ); + } + + if (!modulePath) { + modulePath = this._resolveModule( + from, + moduleName, + isInternal + ? undefined + : { + conditions: this.cjsConditions + } + ); + } + + if (this.unstable_shouldLoadAsEsm(modulePath)) { + // Node includes more info in the message + const error = new Error( + `Must use import to load ES Module: ${modulePath}` + ); // @ts-expect-error: `code` is not defined + + error.code = 'ERR_REQUIRE_ESM'; + throw error; + } + + let moduleRegistry; + + if (isInternal) { + moduleRegistry = this._internalModuleRegistry; + } else if (this._isolatedModuleRegistry) { + moduleRegistry = this._isolatedModuleRegistry; + } else { + moduleRegistry = this._moduleRegistry; + } + + const module = moduleRegistry.get(modulePath); + + if (module) { + return module.exports; + } // We must register the pre-allocated module object first so that any + // circular dependencies that may arise while evaluating the module can + // be satisfied. + + const localModule = { + children: [], + exports: {}, + filename: modulePath, + id: modulePath, + loaded: false, + path: path().dirname(modulePath) + }; + moduleRegistry.set(modulePath, localModule); + + try { + this._loadModule( + localModule, + from, + moduleName, + modulePath, + options, + moduleRegistry + ); + } catch (error) { + moduleRegistry.delete(modulePath); + throw error; + } + + return localModule.exports; + } + + requireInternalModule(from, to) { + if (to) { + var _nativeModule$createR; + + const require = ( + (_nativeModule$createR = nativeModule().createRequire) !== null && + _nativeModule$createR !== void 0 + ? _nativeModule$createR + : nativeModule().createRequireFromPath + )(from); + + if (INTERNAL_MODULE_REQUIRE_OUTSIDE_OPTIMIZED_MODULES.has(to)) { + return require(to); + } + + const outsideJestVmPath = (0, _helpers.decodePossibleOutsideJestVmPath)( + to + ); + + if (outsideJestVmPath) { + return require(outsideJestVmPath); + } + } + + return this.requireModule(from, to, { + isInternalModule: true, + supportsDynamicImport: esmIsAvailable, + supportsExportNamespaceFrom: false, + supportsStaticESM: false, + supportsTopLevelAwait: false + }); + } + + requireActual(from, moduleName) { + return this.requireModule(from, moduleName, undefined, true); + } + + requireMock(from, moduleName) { + var _this$_isolatedMockRe; + + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + { + conditions: this.cjsConditions + } + ); + + if ( + (_this$_isolatedMockRe = this._isolatedMockRegistry) !== null && + _this$_isolatedMockRe !== void 0 && + _this$_isolatedMockRe.has(moduleID) + ) { + return this._isolatedMockRegistry.get(moduleID); + } else if (this._mockRegistry.has(moduleID)) { + return this._mockRegistry.get(moduleID); + } + + const mockRegistry = this._isolatedMockRegistry || this._mockRegistry; + + if (this._mockFactories.has(moduleID)) { + // has check above makes this ok + const module = this._mockFactories.get(moduleID)(); + + mockRegistry.set(moduleID, module); + return module; + } + + const manualMockOrStub = this._resolver.getMockModule(from, moduleName); + + let modulePath = + this._resolver.getMockModule(from, moduleName) || + this._resolveModule(from, moduleName, { + conditions: this.cjsConditions + }); + + let isManualMock = + manualMockOrStub && + !this._resolver.resolveStubModuleName(from, moduleName); + + if (!isManualMock) { + // If the actual module file has a __mocks__ dir sitting immediately next + // to it, look to see if there is a manual mock for this file. + // + // subDir1/my_module.js + // subDir1/__mocks__/my_module.js + // subDir2/my_module.js + // subDir2/__mocks__/my_module.js + // + // Where some other module does a relative require into each of the + // respective subDir{1,2} directories and expects a manual mock + // corresponding to that particular my_module.js file. + const moduleDir = path().dirname(modulePath); + const moduleFileName = path().basename(modulePath); + const potentialManualMock = path().join( + moduleDir, + '__mocks__', + moduleFileName + ); + + if (fs().existsSync(potentialManualMock)) { + isManualMock = true; + modulePath = potentialManualMock; + } + } + + if (isManualMock) { + const localModule = { + children: [], + exports: {}, + filename: modulePath, + id: modulePath, + loaded: false, + path: path().dirname(modulePath) + }; + + this._loadModule( + localModule, + from, + moduleName, + modulePath, + undefined, + mockRegistry + ); + + mockRegistry.set(moduleID, localModule.exports); + } else { + // Look for a real module to generate an automock from + mockRegistry.set(moduleID, this._generateMock(from, moduleName)); + } + + return mockRegistry.get(moduleID); + } + + _loadModule( + localModule, + from, + moduleName, + modulePath, + options, + moduleRegistry + ) { + if (path().extname(modulePath) === '.json') { + const text = (0, _stripBom().default)(this.readFile(modulePath)); + + const transformedFile = this._scriptTransformer.transformJson( + modulePath, + this._getFullTransformationOptions(options), + text + ); + + localModule.exports = + this._environment.global.JSON.parse(transformedFile); + } else if (path().extname(modulePath) === '.node') { + localModule.exports = require(modulePath); + } else { + // Only include the fromPath if a moduleName is given. Else treat as root. + const fromPath = moduleName ? from : null; + + this._execModule(localModule, options, moduleRegistry, fromPath); + } + + localModule.loaded = true; + } + + _getFullTransformationOptions(options = defaultTransformOptions) { + return {...options, ...this._coverageOptions}; + } + + requireModuleOrMock(from, moduleName) { + // this module is unmockable + if (moduleName === '@jest/globals') { + // @ts-expect-error: we don't care that it's not assignable to T + return this.getGlobalsForCjs(from); + } + + try { + if ( + this._shouldMock(from, moduleName, this._explicitShouldMock, { + conditions: this.cjsConditions + }) + ) { + return this.requireMock(from, moduleName); + } else { + return this.requireModule(from, moduleName); + } + } catch (e) { + const moduleNotFound = + _jestResolve().default.tryCastModuleNotFoundError(e); + + if (moduleNotFound) { + if ( + moduleNotFound.siblingWithSimilarExtensionFound === null || + moduleNotFound.siblingWithSimilarExtensionFound === undefined + ) { + moduleNotFound.hint = (0, _helpers.findSiblingsWithFileExtension)( + this._config.moduleFileExtensions, + from, + moduleNotFound.moduleName || moduleName + ); + moduleNotFound.siblingWithSimilarExtensionFound = Boolean( + moduleNotFound.hint + ); + } + + moduleNotFound.buildMessage(this._config.rootDir); + throw moduleNotFound; + } + + throw e; + } + } + + isolateModules(fn) { + if (this._isolatedModuleRegistry || this._isolatedMockRegistry) { + throw new Error( + 'isolateModules cannot be nested inside another isolateModules.' + ); + } + + this._isolatedModuleRegistry = new Map(); + this._isolatedMockRegistry = new Map(); + + try { + fn(); + } finally { + var _this$_isolatedModule, _this$_isolatedMockRe2; + + // might be cleared within the callback + (_this$_isolatedModule = this._isolatedModuleRegistry) === null || + _this$_isolatedModule === void 0 + ? void 0 + : _this$_isolatedModule.clear(); + (_this$_isolatedMockRe2 = this._isolatedMockRegistry) === null || + _this$_isolatedMockRe2 === void 0 + ? void 0 + : _this$_isolatedMockRe2.clear(); + this._isolatedModuleRegistry = null; + this._isolatedMockRegistry = null; + } + } + + resetModules() { + var _this$_isolatedModule2, _this$_isolatedMockRe3; + + (_this$_isolatedModule2 = this._isolatedModuleRegistry) === null || + _this$_isolatedModule2 === void 0 + ? void 0 + : _this$_isolatedModule2.clear(); + (_this$_isolatedMockRe3 = this._isolatedMockRegistry) === null || + _this$_isolatedMockRe3 === void 0 + ? void 0 + : _this$_isolatedMockRe3.clear(); + this._isolatedModuleRegistry = null; + this._isolatedMockRegistry = null; + + this._mockRegistry.clear(); + + this._moduleRegistry.clear(); + + this._esmoduleRegistry.clear(); + + this._cjsNamedExports.clear(); + + this._moduleMockRegistry.clear(); + + if (this._environment) { + if (this._environment.global) { + const envGlobal = this._environment.global; + Object.keys(envGlobal).forEach(key => { + const globalMock = envGlobal[key]; + + if ( + ((typeof globalMock === 'object' && globalMock !== null) || + typeof globalMock === 'function') && + globalMock._isMockFunction === true + ) { + globalMock.mockClear(); + } + }); + } + + if (this._environment.fakeTimers) { + this._environment.fakeTimers.clearAllTimers(); + } + } + } + + async collectV8Coverage() { + this._v8CoverageInstrumenter = + new (_collectV8Coverage().CoverageInstrumenter)(); + await this._v8CoverageInstrumenter.startInstrumenting(); + } + + async stopCollectingV8Coverage() { + if (!this._v8CoverageInstrumenter) { + throw new Error('You need to call `collectV8Coverage` first.'); + } + + this._v8CoverageResult = + await this._v8CoverageInstrumenter.stopInstrumenting(); + } + + getAllCoverageInfoCopy() { + return (0, _jestUtil().deepCyclicCopy)( + this._environment.global.__coverage__ + ); + } + + getAllV8CoverageInfoCopy() { + if (!this._v8CoverageResult) { + throw new Error('You need to `stopCollectingV8Coverage` first'); + } + + return this._v8CoverageResult + .filter(res => res.url.startsWith('file://')) + .map(res => ({...res, url: (0, _url().fileURLToPath)(res.url)})) + .filter( + ( + res // TODO: will this work on windows? It might be better if `shouldInstrument` deals with it anyways + ) => + res.url.startsWith(this._config.rootDir) && + this._fileTransforms.has(res.url) && + (0, _transform().shouldInstrument)( + res.url, + this._coverageOptions, + this._config + ) + ) + .map(result => { + const transformedFile = this._fileTransforms.get(result.url); + + return { + codeTransformResult: transformedFile, + result + }; + }); + } + + getSourceMaps() { + return this._sourceMapRegistry; + } + + setMock(from, moduleName, mockFactory, options) { + if (options !== null && options !== void 0 && options.virtual) { + const mockPath = this._resolver.getModulePath(from, moduleName); + + this._virtualMocks.set(mockPath, true); + } + + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + { + conditions: this.cjsConditions + } + ); + + this._explicitShouldMock.set(moduleID, true); + + this._mockFactories.set(moduleID, mockFactory); + } + + setModuleMock(from, moduleName, mockFactory, options) { + if (options !== null && options !== void 0 && options.virtual) { + const mockPath = this._resolver.getModulePath(from, moduleName); + + this._virtualModuleMocks.set(mockPath, true); + } + + const moduleID = this._resolver.getModuleID( + this._virtualModuleMocks, + from, + moduleName, + { + conditions: this.esmConditions + } + ); + + this._explicitShouldMockModule.set(moduleID, true); + + this._moduleMockFactories.set(moduleID, mockFactory); + } + + restoreAllMocks() { + this._moduleMocker.restoreAllMocks(); + } + + resetAllMocks() { + this._moduleMocker.resetAllMocks(); + } + + clearAllMocks() { + this._moduleMocker.clearAllMocks(); + } + + teardown() { + this.restoreAllMocks(); + this.resetAllMocks(); + this.resetModules(); + + this._internalModuleRegistry.clear(); + + this._mainModule = null; + + this._mockFactories.clear(); + + this._moduleMockFactories.clear(); + + this._mockMetaDataCache.clear(); + + this._shouldMockModuleCache.clear(); + + this._shouldUnmockTransitiveDependenciesCache.clear(); + + this._explicitShouldMock.clear(); + + this._explicitShouldMockModule.clear(); + + this._transitiveShouldMock.clear(); + + this._virtualMocks.clear(); + + this._virtualModuleMocks.clear(); + + this._cacheFS.clear(); + + this._unmockList = undefined; + + this._sourceMapRegistry.clear(); + + this._fileTransforms.clear(); + + this._fileTransformsMutex.clear(); + + this.jestObjectCaches.clear(); + this._v8CoverageResult = []; + this._v8CoverageInstrumenter = undefined; + this._moduleImplementation = undefined; + this.isTornDown = true; + } + + _resolveModule(from, to, options) { + return to ? this._resolver.resolveModule(from, to, options) : from; + } + + _requireResolve(from, moduleName, options = {}) { + if (moduleName == null) { + throw new Error( + 'The first argument to require.resolve must be a string. Received null or undefined.' + ); + } + + if (path().isAbsolute(moduleName)) { + const module = this._resolver.resolveModuleFromDirIfExists( + moduleName, + moduleName, + { + conditions: this.cjsConditions, + paths: [] + } + ); + + if (module) { + return module; + } + } else { + const {paths} = options; + + if (paths) { + for (const p of paths) { + const absolutePath = path().resolve(from, '..', p); + + const module = this._resolver.resolveModuleFromDirIfExists( + absolutePath, + moduleName, // required to also resolve files without leading './' directly in the path + { + conditions: this.cjsConditions, + paths: [absolutePath] + } + ); + + if (module) { + return module; + } + } + + throw new (_jestResolve().default.ModuleNotFoundError)( + `Cannot resolve module '${moduleName}' from paths ['${paths.join( + "', '" + )}'] from ${from}` + ); + } + } + + try { + return this._resolveModule(from, moduleName, { + conditions: this.cjsConditions + }); + } catch (err) { + const module = this._resolver.getMockModule(from, moduleName); + + if (module) { + return module; + } else { + throw err; + } + } + } + + _requireResolvePaths(from, moduleName) { + if (moduleName == null) { + throw new Error( + 'The first argument to require.resolve.paths must be a string. Received null or undefined.' + ); + } + + if (!moduleName.length) { + throw new Error( + 'The first argument to require.resolve.paths must not be the empty string.' + ); + } + + if (moduleName[0] === '.') { + return [path().resolve(from, '..')]; + } + + if (this._resolver.isCoreModule(moduleName)) { + return null; + } + + return this._resolver.getModulePaths(path().resolve(from, '..')); + } + + _execModule(localModule, options, moduleRegistry, from) { + if (this.isTornDown) { + this._logFormattedReferenceError( + 'You are trying to `import` a file after the Jest environment has been torn down.' + ); + + process.exitCode = 1; + return; + } // If the environment was disposed, prevent this module from being executed. + + if (!this._environment.global) { + return; + } + + const module = localModule; + const filename = module.filename; + const lastExecutingModulePath = this._currentlyExecutingModulePath; + this._currentlyExecutingModulePath = filename; + const origCurrExecutingManualMock = this._isCurrentlyExecutingManualMock; + this._isCurrentlyExecutingManualMock = filename; + module.children = []; + Object.defineProperty(module, 'parent', { + enumerable: true, + + get() { + const key = from || ''; + return moduleRegistry.get(key) || null; + } + }); + module.paths = this._resolver.getModulePaths(module.path); + Object.defineProperty(module, 'require', { + value: this._createRequireImplementation(module, options) + }); + const transformedCode = this.transformFile(filename, options); + let compiledFunction = null; + const script = this.createScriptFromCode(transformedCode, filename); + let runScript = null; + + const vmContext = this._environment.getVmContext(); + + if (vmContext) { + runScript = script.runInContext(vmContext, { + filename + }); + } + + if (runScript !== null) { + compiledFunction = runScript[EVAL_RESULT_VARIABLE]; + } + + if (compiledFunction === null) { + this._logFormattedReferenceError( + 'You are trying to `import` a file after the Jest environment has been torn down.' + ); + + process.exitCode = 1; + return; + } + + const jestObject = this._createJestObjectFor(filename); + + this.jestObjectCaches.set(filename, jestObject); + const lastArgs = [ + this._config.injectGlobals ? jestObject : undefined, // jest object + ...this._config.extraGlobals.map(globalVariable => { + if (this._environment.global[globalVariable]) { + return this._environment.global[globalVariable]; + } + + throw new Error( + `You have requested '${globalVariable}' as a global variable, but it was not present. Please check your config or your global environment.` + ); + }) + ]; + + if (!this._mainModule && filename === this._testPath) { + this._mainModule = module; + } + + Object.defineProperty(module, 'main', { + enumerable: true, + value: this._mainModule + }); + + try { + compiledFunction.call( + module.exports, + module, // module object + module.exports, // module exports + module.require, // require implementation + module.path, // __dirname + module.filename, // __filename + // @ts-expect-error + ...lastArgs.filter(notEmpty) + ); + } catch (error) { + this.handleExecutionError(error, module); + } + + this._isCurrentlyExecutingManualMock = origCurrExecutingManualMock; + this._currentlyExecutingModulePath = lastExecutingModulePath; + } + + transformFile(filename, options) { + const source = this.readFile(filename); + + if (options !== null && options !== void 0 && options.isInternalModule) { + return source; + } + + let transformedFile = this._fileTransforms.get(filename); + + if (transformedFile) { + return transformedFile.code; + } + + transformedFile = this._scriptTransformer.transform( + filename, + this._getFullTransformationOptions(options), + source + ); + + this._fileTransforms.set(filename, { + ...transformedFile, + wrapperLength: this.constructModuleWrapperStart().length + }); + + if (transformedFile.sourceMapPath) { + this._sourceMapRegistry.set(filename, transformedFile.sourceMapPath); + } + + return transformedFile.code; + } + + async transformFileAsync(filename, options) { + const source = this.readFile(filename); + + if (options !== null && options !== void 0 && options.isInternalModule) { + return source; + } + + let transformedFile = this._fileTransforms.get(filename); + + if (transformedFile) { + return transformedFile.code; + } + + transformedFile = await this._scriptTransformer.transformAsync( + filename, + this._getFullTransformationOptions(options), + source + ); + + this._fileTransforms.set(filename, {...transformedFile, wrapperLength: 0}); + + if (transformedFile.sourceMapPath) { + this._sourceMapRegistry.set(filename, transformedFile.sourceMapPath); + } + + return transformedFile.code; + } + + createScriptFromCode(scriptSource, filename) { + try { + const scriptFilename = this._resolver.isCoreModule(filename) + ? `jest-nodejs-core-${filename}` + : filename; + return new (_vm().Script)(this.wrapCodeInModuleWrapper(scriptSource), { + displayErrors: true, + filename: scriptFilename, + // @ts-expect-error: Experimental ESM API + importModuleDynamically: async specifier => { + var _this$_environment$ge, _this$_environment2; + + invariant( + runtimeSupportsVmModules, + 'You need to run with a version of node that supports ES Modules in the VM API. See https://jestjs.io/docs/ecmascript-modules' + ); + const context = + (_this$_environment$ge = (_this$_environment2 = this._environment) + .getVmContext) === null || _this$_environment$ge === void 0 + ? void 0 + : _this$_environment$ge.call(_this$_environment2); + invariant(context, 'Test environment has been torn down'); + const module = await this.resolveModule( + specifier, + scriptFilename, + context + ); + return this.linkAndEvaluateModule(module); + } + }); + } catch (e) { + throw (0, _transform().handlePotentialSyntaxError)(e); + } + } + + _requireCoreModule(moduleName, supportPrefix) { + const moduleWithoutNodePrefix = + supportPrefix && moduleName.startsWith('node:') + ? moduleName.slice('node:'.length) + : moduleName; + + if (moduleWithoutNodePrefix === 'process') { + return this._environment.global.process; + } + + if (moduleWithoutNodePrefix === 'module') { + return this._getMockedNativeModule(); + } + + return require(moduleWithoutNodePrefix); + } + + _importCoreModule(moduleName, context) { + const required = this._requireCoreModule( + moduleName, + supportsNodeColonModulePrefixInImport + ); + + const module = new (_vm().SyntheticModule)( + ['default', ...Object.keys(required)], + function () { + // @ts-expect-error: TS doesn't know what `this` is + this.setExport('default', required); + Object.entries(required).forEach(([key, value]) => { + // @ts-expect-error: TS doesn't know what `this` is + this.setExport(key, value); + }); + }, // should identifier be `node://${moduleName}`? + { + context, + identifier: moduleName + } + ); + return evaluateSyntheticModule(module); + } + + _getMockedNativeModule() { + if (this._moduleImplementation) { + return this._moduleImplementation; + } + + const createRequire = modulePath => { + const filename = + typeof modulePath === 'string' + ? modulePath.startsWith('file:///') + ? (0, _url().fileURLToPath)(new (_url().URL)(modulePath)) + : modulePath + : (0, _url().fileURLToPath)(modulePath); + + if (!path().isAbsolute(filename)) { + const error = new TypeError( + `The argument 'filename' must be a file URL object, file URL string, or absolute path string. Received '${filename}'` + ); // @ts-expect-error + + error.code = 'ERR_INVALID_ARG_TYPE'; + throw error; + } + + return this._createRequireImplementation({ + children: [], + exports: {}, + filename, + id: filename, + loaded: false, + path: path().dirname(filename) + }); + }; // should we implement the class ourselves? + + class Module extends nativeModule().Module {} + + Object.entries(nativeModule().Module).forEach(([key, value]) => { + // @ts-expect-error + Module[key] = value; + }); + Module.Module = Module; + + if ('createRequire' in nativeModule()) { + Module.createRequire = createRequire; + } + + if ('createRequireFromPath' in nativeModule()) { + Module.createRequireFromPath = function createRequireFromPath(filename) { + if (typeof filename !== 'string') { + const error = new TypeError( + `The argument 'filename' must be string. Received '${filename}'.${ + filename instanceof _url().URL + ? ' Use createRequire for URL filename.' + : '' + }` + ); // @ts-expect-error + + error.code = 'ERR_INVALID_ARG_TYPE'; + throw error; + } + + return createRequire(filename); + }; + } + + if ('syncBuiltinESMExports' in nativeModule()) { + // cast since TS seems very confused about whether it exists or not + Module.syncBuiltinESMExports = function syncBuiltinESMExports() {}; + } + + this._moduleImplementation = Module; + return Module; + } + + _generateMock(from, moduleName) { + const modulePath = + this._resolver.resolveStubModuleName(from, moduleName) || + this._resolveModule(from, moduleName, { + conditions: this.cjsConditions + }); + + if (!this._mockMetaDataCache.has(modulePath)) { + // This allows us to handle circular dependencies while generating an + // automock + this._mockMetaDataCache.set( + modulePath, + this._moduleMocker.getMetadata({}) || {} + ); // In order to avoid it being possible for automocking to potentially + // cause side-effects within the module environment, we need to execute + // the module in isolation. This could cause issues if the module being + // mocked has calls into side-effectful APIs on another module. + + const origMockRegistry = this._mockRegistry; + const origModuleRegistry = this._moduleRegistry; + this._mockRegistry = new Map(); + this._moduleRegistry = new Map(); + const moduleExports = this.requireModule(from, moduleName); // Restore the "real" module/mock registries + + this._mockRegistry = origMockRegistry; + this._moduleRegistry = origModuleRegistry; + + const mockMetadata = this._moduleMocker.getMetadata(moduleExports); + + if (mockMetadata == null) { + throw new Error( + `Failed to get mock metadata: ${modulePath}\n\n` + + 'See: https://jestjs.io/docs/manual-mocks#content' + ); + } + + this._mockMetaDataCache.set(modulePath, mockMetadata); + } + + return this._moduleMocker.generateFromMetadata( + // added above if missing + this._mockMetaDataCache.get(modulePath) + ); + } + + _shouldMock(from, moduleName, explicitShouldMock, options) { + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + options + ); + + const key = from + path().delimiter + moduleID; + + if (explicitShouldMock.has(moduleID)) { + // guaranteed by `has` above + return explicitShouldMock.get(moduleID); + } + + if ( + !this._shouldAutoMock || + this._resolver.isCoreModule(moduleName) || + this._shouldUnmockTransitiveDependenciesCache.get(key) + ) { + return false; + } + + if (this._shouldMockModuleCache.has(moduleID)) { + // guaranteed by `has` above + return this._shouldMockModuleCache.get(moduleID); + } + + let modulePath; + + try { + modulePath = this._resolveModule(from, moduleName, options); + } catch (e) { + const manualMock = this._resolver.getMockModule(from, moduleName); + + if (manualMock) { + this._shouldMockModuleCache.set(moduleID, true); + + return true; + } + + throw e; + } + + if (this._unmockList && this._unmockList.test(modulePath)) { + this._shouldMockModuleCache.set(moduleID, false); + + return false; + } // transitive unmocking for package managers that store flat packages (npm3) + + const currentModuleID = this._resolver.getModuleID( + this._virtualMocks, + from, + undefined, + options + ); + + if ( + this._transitiveShouldMock.get(currentModuleID) === false || + (from.includes(NODE_MODULES) && + modulePath.includes(NODE_MODULES) && + ((this._unmockList && this._unmockList.test(from)) || + explicitShouldMock.get(currentModuleID) === false)) + ) { + this._transitiveShouldMock.set(moduleID, false); + + this._shouldUnmockTransitiveDependenciesCache.set(key, true); + + return false; + } + + this._shouldMockModuleCache.set(moduleID, true); + + return true; + } + + _createRequireImplementation(from, options) { + const resolve = (moduleName, resolveOptions) => { + const resolved = this._requireResolve( + from.filename, + moduleName, + resolveOptions + ); + + if ( + resolveOptions !== null && + resolveOptions !== void 0 && + resolveOptions[JEST_RESOLVE_OUTSIDE_VM_OPTION] && + options !== null && + options !== void 0 && + options.isInternalModule + ) { + return (0, _helpers.createOutsideJestVmPath)(resolved); + } + + return resolved; + }; + + resolve.paths = moduleName => + this._requireResolvePaths(from.filename, moduleName); + + const moduleRequire = + options !== null && options !== void 0 && options.isInternalModule + ? moduleName => this.requireInternalModule(from.filename, moduleName) + : this.requireModuleOrMock.bind(this, from.filename); + moduleRequire.extensions = Object.create(null); + moduleRequire.resolve = resolve; + + moduleRequire.cache = (() => { + // TODO: consider warning somehow that this does nothing. We should support deletions, anyways + const notPermittedMethod = () => true; + + return new Proxy(Object.create(null), { + defineProperty: notPermittedMethod, + deleteProperty: notPermittedMethod, + get: (_target, key) => + typeof key === 'string' ? this._moduleRegistry.get(key) : undefined, + + getOwnPropertyDescriptor() { + return { + configurable: true, + enumerable: true + }; + }, + + has: (_target, key) => + typeof key === 'string' && this._moduleRegistry.has(key), + ownKeys: () => Array.from(this._moduleRegistry.keys()), + set: notPermittedMethod + }); + })(); + + Object.defineProperty(moduleRequire, 'main', { + enumerable: true, + value: this._mainModule + }); + return moduleRequire; + } + + _createJestObjectFor(from) { + var _this$_moduleMocker$m, _this$_moduleMocker$m2; + + const disableAutomock = () => { + this._shouldAutoMock = false; + return jestObject; + }; + + const enableAutomock = () => { + this._shouldAutoMock = true; + return jestObject; + }; + + const unmock = moduleName => { + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + { + conditions: this.cjsConditions + } + ); + + this._explicitShouldMock.set(moduleID, false); + + return jestObject; + }; + + const deepUnmock = moduleName => { + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + { + conditions: this.cjsConditions + } + ); + + this._explicitShouldMock.set(moduleID, false); + + this._transitiveShouldMock.set(moduleID, false); + + return jestObject; + }; + + const mock = (moduleName, mockFactory, options) => { + if (mockFactory !== undefined) { + return setMockFactory(moduleName, mockFactory, options); + } + + const moduleID = this._resolver.getModuleID( + this._virtualMocks, + from, + moduleName, + { + conditions: this.cjsConditions + } + ); + + this._explicitShouldMock.set(moduleID, true); + + return jestObject; + }; + + const setMockFactory = (moduleName, mockFactory, options) => { + this.setMock(from, moduleName, mockFactory, options); + return jestObject; + }; + + const mockModule = (moduleName, mockFactory, options) => { + if (typeof mockFactory !== 'function') { + throw new Error('`unstable_mockModule` must be passed a mock factory'); + } + + this.setModuleMock(from, moduleName, mockFactory, options); + return jestObject; + }; + + const clearAllMocks = () => { + this.clearAllMocks(); + return jestObject; + }; + + const resetAllMocks = () => { + this.resetAllMocks(); + return jestObject; + }; + + const restoreAllMocks = () => { + this.restoreAllMocks(); + return jestObject; + }; + + const _getFakeTimers = () => { + if ( + this.isTornDown || + !(this._environment.fakeTimers || this._environment.fakeTimersModern) + ) { + this._logFormattedReferenceError( + 'You are trying to access a property or method of the Jest environment after it has been torn down.' + ); + + process.exitCode = 1; + } + + return this._fakeTimersImplementation; + }; + + const useFakeTimers = (type = 'modern') => { + if (type === 'legacy') { + this._fakeTimersImplementation = this._environment.fakeTimers; + } else { + this._fakeTimersImplementation = this._environment.fakeTimersModern; + } + + this._fakeTimersImplementation.useFakeTimers(); + + return jestObject; + }; + + const useRealTimers = () => { + _getFakeTimers().useRealTimers(); + + return jestObject; + }; + + const resetModules = () => { + this.resetModules(); + return jestObject; + }; + + const isolateModules = fn => { + this.isolateModules(fn); + return jestObject; + }; + + const fn = this._moduleMocker.fn.bind(this._moduleMocker); + + const spyOn = this._moduleMocker.spyOn.bind(this._moduleMocker); + + const mocked = + (_this$_moduleMocker$m = + (_this$_moduleMocker$m2 = this._moduleMocker.mocked) === null || + _this$_moduleMocker$m2 === void 0 + ? void 0 + : _this$_moduleMocker$m2.bind(this._moduleMocker)) !== null && + _this$_moduleMocker$m !== void 0 + ? _this$_moduleMocker$m + : () => { + throw new Error( + 'Your test environment does not support `mocked`, please update it.' + ); + }; + + const setTimeout = timeout => { + if (this._environment.global.jasmine) { + this._environment.global.jasmine._DEFAULT_TIMEOUT_INTERVAL = timeout; + } else { + // @ts-expect-error: https://github.com/Microsoft/TypeScript/issues/24587 + this._environment.global[testTimeoutSymbol] = timeout; + } + + return jestObject; + }; + + const retryTimes = numTestRetries => { + // @ts-expect-error: https://github.com/Microsoft/TypeScript/issues/24587 + this._environment.global[retryTimesSymbol] = numTestRetries; + return jestObject; + }; + + const jestObject = { + advanceTimersByTime: msToRun => + _getFakeTimers().advanceTimersByTime(msToRun), + advanceTimersToNextTimer: steps => + _getFakeTimers().advanceTimersToNextTimer(steps), + autoMockOff: disableAutomock, + autoMockOn: enableAutomock, + clearAllMocks, + clearAllTimers: () => _getFakeTimers().clearAllTimers(), + createMockFromModule: moduleName => this._generateMock(from, moduleName), + deepUnmock, + disableAutomock, + doMock: mock, + dontMock: unmock, + enableAutomock, + fn, + genMockFromModule: moduleName => this._generateMock(from, moduleName), + getRealSystemTime: () => { + const fakeTimers = _getFakeTimers(); + + if (fakeTimers === this._environment.fakeTimersModern) { + return fakeTimers.getRealSystemTime(); + } else { + throw new TypeError( + 'getRealSystemTime is not available when not using modern timers' + ); + } + }, + getTimerCount: () => _getFakeTimers().getTimerCount(), + isMockFunction: this._moduleMocker.isMockFunction, + isolateModules, + mock, + mocked, + requireActual: this.requireActual.bind(this, from), + requireMock: this.requireMock.bind(this, from), + resetAllMocks, + resetModules, + restoreAllMocks, + retryTimes, + runAllImmediates: () => { + const fakeTimers = _getFakeTimers(); + + if (fakeTimers === this._environment.fakeTimers) { + fakeTimers.runAllImmediates(); + } else { + throw new TypeError( + 'runAllImmediates is not available when using modern timers' + ); + } + }, + runAllTicks: () => _getFakeTimers().runAllTicks(), + runAllTimers: () => _getFakeTimers().runAllTimers(), + runOnlyPendingTimers: () => _getFakeTimers().runOnlyPendingTimers(), + setMock: (moduleName, mock) => setMockFactory(moduleName, () => mock), + setSystemTime: now => { + const fakeTimers = _getFakeTimers(); + + if (fakeTimers === this._environment.fakeTimersModern) { + fakeTimers.setSystemTime(now); + } else { + throw new TypeError( + 'setSystemTime is not available when not using modern timers' + ); + } + }, + setTimeout, + spyOn, + unmock, + unstable_mockModule: mockModule, + useFakeTimers, + useRealTimers + }; + return jestObject; + } + + _logFormattedReferenceError(errorMessage) { + const testPath = this._testPath + ? ` From ${(0, _slash().default)( + path().relative(this._config.rootDir, this._testPath) + )}.` + : ''; + const originalStack = new ReferenceError(`${errorMessage}${testPath}`).stack + .split('\n') // Remove this file from the stack (jest-message-utils will keep one line) + .filter(line => line.indexOf(__filename) === -1) + .join('\n'); + const {message, stack} = (0, _jestMessageUtil().separateMessageFromStack)( + originalStack + ); + console.error( + `\n${message}\n` + + (0, _jestMessageUtil().formatStackTrace)(stack, this._config, { + noStackTrace: false + }) + ); + } + + wrapCodeInModuleWrapper(content) { + return this.constructModuleWrapperStart() + content + '\n}});'; + } + + constructModuleWrapperStart() { + const args = this.constructInjectedModuleParameters(); + return '({"' + EVAL_RESULT_VARIABLE + `":function(${args.join(',')}){`; + } + + constructInjectedModuleParameters() { + return [ + 'module', + 'exports', + 'require', + '__dirname', + '__filename', + this._config.injectGlobals ? 'jest' : undefined, + ...this._config.extraGlobals + ].filter(notEmpty); + } + + handleExecutionError(e, module) { + const moduleNotFoundError = + _jestResolve().default.tryCastModuleNotFoundError(e); + + if (moduleNotFoundError) { + if (!moduleNotFoundError.requireStack) { + moduleNotFoundError.requireStack = [module.filename || module.id]; + + for (let cursor = module.parent; cursor; cursor = cursor.parent) { + moduleNotFoundError.requireStack.push(cursor.filename || cursor.id); + } + + moduleNotFoundError.buildMessage(this._config.rootDir); + } + + throw moduleNotFoundError; + } + + throw e; + } + + getGlobalsForCjs(from) { + const jest = this.jestObjectCaches.get(from); + invariant(jest, 'There should always be a Jest object already'); + return {...this.getGlobalsFromEnvironment(), jest}; + } + + getGlobalsForEsm(from, context) { + let jest = this.jestObjectCaches.get(from); + + if (!jest) { + jest = this._createJestObjectFor(from); + this.jestObjectCaches.set(from, jest); + } + + const globals = {...this.getGlobalsFromEnvironment(), jest}; + const module = new (_vm().SyntheticModule)( + Object.keys(globals), + function () { + Object.entries(globals).forEach(([key, value]) => { + // @ts-expect-error: TS doesn't know what `this` is + this.setExport(key, value); + }); + }, + { + context, + identifier: '@jest/globals' + } + ); + return evaluateSyntheticModule(module); + } + + getGlobalsFromEnvironment() { + if (this.jestGlobals) { + return {...this.jestGlobals}; + } + + return { + afterAll: this._environment.global.afterAll, + afterEach: this._environment.global.afterEach, + beforeAll: this._environment.global.beforeAll, + beforeEach: this._environment.global.beforeEach, + describe: this._environment.global.describe, + expect: this._environment.global.expect, + fdescribe: this._environment.global.fdescribe, + fit: this._environment.global.fit, + it: this._environment.global.it, + test: this._environment.global.test, + xdescribe: this._environment.global.xdescribe, + xit: this._environment.global.xit, + xtest: this._environment.global.xtest + }; + } + + readFile(filename) { + let source = this._cacheFS.get(filename); + + if (!source) { + source = fs().readFileSync(filename, 'utf8'); + + this._cacheFS.set(filename, source); + } + + return source; + } + + setGlobalsForRuntime(globals) { + this.jestGlobals = globals; + } +} + +exports.default = Runtime; + +_defineProperty(Runtime, 'shouldInstrument', _transform().shouldInstrument); + +function invariant(condition, message) { + if (!condition) { + throw new Error(message); + } +} + +function notEmpty(value) { + return value !== null && value !== undefined; +} + +async function evaluateSyntheticModule(module) { + await module.link(() => { + throw new Error('This should never happen'); + }); + await module.evaluate(); + return module; +} |