actions/setup-helm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

v2 new release (#77)

Browse Source
This commit is contained in:
github-actions[bot]
2022-06-27 14:12:49 -04:00
committed by GitHub
parent 217bf70cbd
commit 199ab446df
611 changed files with 8668 additions and 45625 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
node_modules/ts-jest/dist/cli/config/init.js generated vendored
View File

@@ -47,14 +47,16 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.help = exports.run = void 0;
var fs_1 = require("fs");
var json5_1 = require("json5");
var path_1 = require("path");
var presets_1 = require("../helpers/presets");
exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
var file, filePath, name, isPackage, exists, pkgFile, hasPackage, _a, jestPreset, askedTsconfig, force, jsdom, tsconfig, pkgJson, jsFilesProcessor, shouldPostProcessWithBabel, preset, body, base, tsJestConf, content;
return __generator(this, function (_b) {
file = args._[0] || 'jest.config.js';
var _b, _c;
return __generator(this, function (_d) {
file = (_c = (_b = args._[0]) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : 'jest.config.js';
filePath = path_1.join(process.cwd(), file);
name = path_1.basename(file);
isPackage = name === 'package.json';

8
node_modules/ts-jest/dist/cli/config/migrate.js generated vendored
View File

@@ -56,18 +56,20 @@ var __spread = (this && this.__spread) || function () {
return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.help = exports.run = void 0;
var bs_logger_1 = require("bs-logger");
var stableStringify = require("fast-json-stable-stringify");
var fs_1 = require("fs");
var json5_1 = require("json5");
var path_1 = require("path");
var backports_1 = require("../../util/backports");
var backports_1 = require("../../utils/backports");
var presets_1 = require("../helpers/presets");
exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
var nullLogger, file, filePath, footNotes, name, isPackage, actualConfig, migratedConfig, presetName, preset, jsTransformers, jsWithTs, jsWithBabel, presetValue, migratedValue, presetValue, migratedValue, before, after, stringify, prefix;
return __generator(this, function (_a) {
var _a;
return __generator(this, function (_b) {
nullLogger = bs_logger_1.createLogger({ targets: [] });
file = args._[0];
file = (_a = args._[0]) === null || _a === void 0 ? void 0 : _a.toString();
filePath = path_1.resolve(process.cwd(), file);
footNotes = [];
if (!fs_1.existsSync(filePath)) {

1
node_modules/ts-jest/dist/cli/help.js generated vendored
View File

@@ -36,6 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.help = exports.run = void 0;
exports.run = function (_) { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
process.stdout.write("\nUsage:\n ts-jest command [options] [...args]\n\nCommands:\n config:init Creates initial Jest configuration\n config:migrate Migrates a given Jest configuration\n help [command] Show this help, or help about a command\n\nExample:\n ts-jest help config:migrate\n");

10
node_modules/ts-jest/dist/cli/helpers/presets.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.jsWIthBabel = exports.jsWithTs = exports.defaults = exports.allPresets = void 0;
var definePreset = function (fullName) { return ({
fullName: fullName,
get name() {
@@ -11,10 +12,11 @@ var definePreset = function (fullName) { return ({
get jsVarName() {
return this.isDefault
? 'defaults'
: fullName
.split('/')
.pop()
.replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
:
fullName
.split('/')
.pop()
.replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
},
get value() {
return require("../../../" + fullName.replace(/^ts-jest\//, '') + "/jest-preset");

10
node_modules/ts-jest/dist/cli/index.js generated vendored
View File

@@ -35,18 +35,22 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.processArgv = void 0;
var bs_logger_1 = require("bs-logger");
var yargsParser = require("yargs-parser");
var logger_1 = require("../util/logger");
var yargs_parser_1 = __importDefault(require("yargs-parser"));
var logger_1 = require("../utils/logger");
var VALID_COMMANDS = ['help', 'config:migrate', 'config:init'];
var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'cli', _a[bs_logger_1.LogContexts.application] = 'ts-jest', _a));
function cli(args) {
return __awaiter(this, void 0, void 0, function () {
var parsedArgv, command, isHelp, _a, run, help, cmd;
return __generator(this, function (_b) {
parsedArgv = yargsParser(args, {
parsedArgv = yargs_parser_1.default(args, {
boolean: ['dry-run', 'jest-preset', 'allow-js', 'diff', 'babel', 'force', 'jsdom'],
string: ['tsconfig', 'js'],
count: ['verbose'],

1
node_modules/ts-jest/dist/compiler/compiler-utils.d.ts generated vendored
View File

@@ -1 +0,0 @@
export {};

33
node_modules/ts-jest/dist/compiler/compiler-utils.js generated vendored
View File

@@ -1,33 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var fs_1 = require("fs");
var micromatch = require("micromatch");
var path_1 = require("path");
var sha1_1 = require("../util/sha1");
function getResolvedModulesCache(cacheDir) {
return path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
}
exports.getResolvedModulesCache = getResolvedModulesCache;
function cacheResolvedModules(fileName, fileContent, memoryCache, program, cacheDir, logger) {
var importReferences = program.getSourceFile(fileName).imports;
if (importReferences.length) {
logger.debug({ fileName: fileName }, 'cacheResolvedModules(): get resolved modules');
memoryCache.resolvedModules[fileName] = Object.create(null);
memoryCache.resolvedModules[fileName].modulePaths = importReferences
.filter(function (importReference) { var _a; return (_a = importReference.parent.parent.resolvedModules) === null || _a === void 0 ? void 0 : _a.get(importReference.text); })
.map(function (importReference) {
return path_1.normalize(importReference.parent.parent.resolvedModules.get(importReference.text)
.resolvedFileName);
})
.reduce(function (a, b) { return a.concat(b); }, []);
memoryCache.resolvedModules[fileName].testFileContent = fileContent;
fs_1.writeFileSync(getResolvedModulesCache(cacheDir), JSON.stringify(memoryCache.resolvedModules));
}
}
exports.cacheResolvedModules = cacheResolvedModules;
function isTestFile(testMatchPatterns, fileName) {
return testMatchPatterns.some(function (pattern) {
return typeof pattern === 'string' ? micromatch.isMatch(fileName, pattern) : pattern.test(fileName);
});
}
exports.isTestFile = isTestFile;

3
node_modules/ts-jest/dist/compiler/instance.d.ts generated vendored
View File

@@ -1 +1,2 @@
export {};
export declare const SOURCE_MAPPING_PREFIX = "sourceMappingURL=";
export declare function updateOutput(outputText: string, normalizedFileName: string, sourceMap: string): string;

71
node_modules/ts-jest/dist/compiler/instance.js generated vendored
View File

@@ -1,15 +1,4 @@
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
@@ -27,70 +16,40 @@ var __read = (this && this.__read) || function (o, n) {
return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
var fs_1 = require("fs");
var mkdirp = require("mkdirp");
var path_1 = require("path");
var compiler_utils_1 = require("./compiler-utils");
exports.createCompilerInstance = exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
var language_service_1 = require("./language-service");
var transpiler_1 = require("./transpiler");
function updateOutput(outputText, normalizedFileName, sourceMap, getExtension) {
var base = path_1.basename(normalizedFileName);
var json_1 = require("../utils/json");
exports.SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
function updateOutput(outputText, normalizedFileName, sourceMap) {
var base64Map = Buffer.from(updateSourceMap(sourceMap, normalizedFileName), 'utf8').toString('base64');
var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
var sourceMapLength = (base + ".map").length + (getExtension(normalizedFileName).length - path_1.extname(normalizedFileName).length);
return outputText.slice(0, -sourceMapLength) + sourceMapContent;
return (outputText.slice(0, outputText.lastIndexOf(exports.SOURCE_MAPPING_PREFIX) + exports.SOURCE_MAPPING_PREFIX.length) + sourceMapContent);
}
exports.updateOutput = updateOutput;
var updateSourceMap = function (sourceMapText, normalizedFileName) {
var sourceMap = JSON.parse(sourceMapText);
sourceMap.file = normalizedFileName;
sourceMap.sources = [normalizedFileName];
delete sourceMap.sourceRoot;
return JSON.stringify(sourceMap);
return json_1.stringify(sourceMap);
};
var compileAndCacheResult = function (memoryCache, compileFn, getExtension, logger) { return function (code, fileName, lineOffset) {
logger.debug({ fileName: fileName }, 'compileAndCacheResult(): get compile output');
var compileAndUpdateOutput = function (compileFn, logger) { return function (code, fileName, lineOffset) {
logger.debug({ fileName: fileName }, 'compileAndUpdateOutput(): get compile output');
var _a = __read(compileFn(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
var output = updateOutput(value, fileName, sourceMap, getExtension);
memoryCache.files.set(fileName, __assign(__assign({}, memoryCache.files.get(fileName)), { output: output }));
return output;
return updateOutput(value, fileName, sourceMap);
}; };
exports.createCompilerInstance = function (configs) {
var logger = configs.logger.child({ namespace: 'ts-compiler' });
var compilerOptions = configs.parsedTsConfig.options, tsJest = configs.tsJest;
var cacheDir = configs.tsCacheDir;
var ts = configs.compilerModule;
var compilerOptions = configs.parsedTsConfig.options;
var extensions = ['.ts', '.tsx'];
var memoryCache = {
files: new Map(),
resolvedModules: Object.create(null),
};
if (compilerOptions.allowJs) {
extensions.push('.js');
extensions.push('.jsx');
}
if (cacheDir) {
mkdirp.sync(cacheDir);
try {
var fsMemoryCache = fs_1.readFileSync(compiler_utils_1.getResolvedModulesCache(cacheDir), 'utf-8');
memoryCache.resolvedModules = JSON.parse(fsMemoryCache);
}
catch (e) { }
}
configs.parsedTsConfig.fileNames.forEach(function (fileName) {
memoryCache.files.set(fileName, {
version: 0,
});
});
var getExtension = compilerOptions.jsx === ts.JsxEmit.Preserve
? function (path) { return (/\.[tj]sx$/.test(path) ? '.jsx' : '.js'); }
: function (_) { return '.js'; };
var compilerInstance;
if (!tsJest.isolatedModules) {
compilerInstance = language_service_1.initializeLanguageServiceInstance(configs, memoryCache, logger);
}
else {
compilerInstance = transpiler_1.initializeTranspilerInstance(configs, memoryCache, logger);
}
var compile = compileAndCacheResult(memoryCache, compilerInstance.compileFn, getExtension, logger);
var compilerInstance = !configs.isolatedModules
? language_service_1.initializeLanguageServiceInstance(configs, logger)
: transpiler_1.initializeTranspilerInstance(configs, logger);
var compile = compileAndUpdateOutput(compilerInstance.compileFn, logger);
return { cwd: configs.cwd, compile: compile, program: compilerInstance.program };
};

191
node_modules/ts-jest/dist/compiler/language-service.js generated vendored
View File

@@ -1,4 +1,40 @@
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
@@ -19,35 +55,100 @@ var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.initializeLanguageServiceInstance = void 0;
var bs_logger_1 = require("bs-logger");
var fs_1 = require("fs");
var path_1 = require("path");
var memoize = require("lodash/memoize");
var mkdirp = require("mkdirp");
var constants_1 = require("../constants");
var messages_1 = require("../util/messages");
var compiler_utils_1 = require("./compiler-utils");
var memoize = require("lodash.memoize");
function doTypeChecking(configs, fileName, service, logger) {
if (configs.shouldReportDiagnostic(fileName)) {
var messages_1 = require("../utils/messages");
var json_1 = require("../utils/json");
var sha1_1 = require("../utils/sha1");
function doTypeChecking(configs, diagnosedFiles, fileName, service, logger) {
if (configs.shouldReportDiagnostics(fileName)) {
var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
diagnosedFiles.push(fileName);
configs.raiseDiagnostics(diagnostics, fileName, logger);
}
}
exports.initializeLanguageServiceInstance = function (configs, memoryCache, logger) {
exports.initializeLanguageServiceInstance = function (configs, logger) {
var _a;
logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
var ts = configs.compilerModule;
var cwd = configs.cwd;
var cacheDir = configs.tsCacheDir;
var _b = configs.parsedTsConfig, options = _b.options, fileNames = _b.fileNames;
var diagnosedFiles = [];
var serviceHostTraceCtx = (_a = {
namespace: 'ts:serviceHost',
call: null
},
_a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
_a);
var memoryCache = {
files: new Map(),
resolvedModules: new Map(),
};
var tsResolvedModulesCachePath;
if (cacheDir) {
mkdirp.sync(cacheDir);
tsResolvedModulesCachePath = path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
try {
var cachedTSResolvedModules = fs_1.readFileSync(tsResolvedModulesCachePath, 'utf-8');
memoryCache.resolvedModules = new Map(json_1.parse(cachedTSResolvedModules));
}
catch (e) { }
}
configs.parsedTsConfig.fileNames
.filter(function (fileName) { return constants_1.TS_TSX_REGEX.test(path_1.extname(fileName)) && !configs.isTestFile(fileName); })
.forEach(function (fileName) {
memoryCache.files.set(fileName, {
version: 0,
});
});
function isFileInCache(fileName) {
return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
}
var cacheReadFile = logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile));
var moduleResolutionHost = {
fileExists: memoize(ts.sys.fileExists),
readFile: cacheReadFile,
directoryExists: memoize(ts.sys.directoryExists),
getCurrentDirectory: function () { return cwd; },
realpath: ts.sys.realpath && memoize(ts.sys.realpath),
getDirectories: memoize(ts.sys.getDirectories),
};
var moduleResolutionCache = ts.createModuleResolutionCache(cwd, function (x) { return x; }, options);
function resolveModuleNames(moduleNames, containingFile) {
var _a;
var normalizedContainingFile = path_1.normalize(containingFile);
var currentResolvedModules = (_a = memoryCache.resolvedModules.get(normalizedContainingFile)) !== null && _a !== void 0 ? _a : [];
return moduleNames.map(function (moduleName) {
var resolveModuleName = ts.resolveModuleName(moduleName, containingFile, options, moduleResolutionHost, moduleResolutionCache);
var resolvedModule = resolveModuleName.resolvedModule;
if (configs.isTestFile(normalizedContainingFile) && resolvedModule) {
var normalizedResolvedFileName = path_1.normalize(resolvedModule.resolvedFileName);
if (!currentResolvedModules.includes(normalizedResolvedFileName)) {
currentResolvedModules.push(normalizedResolvedFileName);
memoryCache.resolvedModules.set(normalizedContainingFile, currentResolvedModules);
}
}
return resolvedModule;
});
}
var projectVersion = 1;
var updateMemoryCache = function (contents, fileName) {
logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
@@ -81,18 +182,19 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
getProjectVersion: function () { return String(projectVersion); },
getScriptFileNames: function () { return __spread(memoryCache.files.keys()); },
getScriptVersion: function (fileName) {
var _a;
var normalizedFileName = path_1.normalize(fileName);
var version = memoryCache.files.get(normalizedFileName).version;
var version = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.version;
return version === undefined ? undefined : String(version);
},
getScriptSnapshot: function (fileName) {
var _a;
var normalizedFileName = path_1.normalize(fileName);
var hit = memoryCache.files.has(normalizedFileName) && memoryCache.files.get(normalizedFileName).version !== 0;
var hit = isFileInCache(normalizedFileName);
logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
if (!hit) {
memoryCache.files.set(normalizedFileName, {
text: ts.sys.readFile(normalizedFileName),
text: cacheReadFile(normalizedFileName),
version: 1,
});
}
@@ -102,46 +204,75 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
return ts.ScriptSnapshot.fromString(contents);
},
fileExists: memoize(ts.sys.fileExists),
readFile: logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile)),
readFile: cacheReadFile,
readDirectory: memoize(ts.sys.readDirectory),
getDirectories: memoize(ts.sys.getDirectories),
directoryExists: memoize(ts.sys.directoryExists),
realpath: memoize(ts.sys.realpath),
realpath: ts.sys.realpath && memoize(ts.sys.realpath),
getNewLine: function () { return constants_1.LINE_FEED; },
getCurrentDirectory: function () { return cwd; },
getCompilationSettings: function () { return options; },
getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); },
getCustomTransformers: function () { return configs.tsCustomTransformers; },
getCustomTransformers: function () { return configs.customTransformers; },
resolveModuleNames: resolveModuleNames,
};
logger.debug('initializeLanguageServiceInstance(): creating language service');
var service = ts.createLanguageService(serviceHost, ts.createDocumentRegistry());
return {
compileFn: function (code, fileName) {
var e_1, _a;
var _b;
logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
updateMemoryCache(code, fileName);
var output = service.getEmitOutput(fileName);
logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
doTypeChecking(configs, fileName, service, logger);
if (cacheDir) {
if (compiler_utils_1.isTestFile(configs.testMatchPatterns, fileName)) {
compiler_utils_1.cacheResolvedModules(fileName, code, memoryCache, service.getProgram(), cacheDir, logger);
}
else {
Object.entries(memoryCache.resolvedModules)
.filter(function (entry) {
return entry[1].modulePaths.find(function (modulePath) { return modulePath === fileName; }) && !memoryCache.files.has(entry[0]);
})
.forEach(function (entry) {
var testFileName = entry[0];
var testFileContent = entry[1].testFileContent;
logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics for test file that imports this module using language service');
updateMemoryCache(testFileContent, testFileName);
doTypeChecking(configs, testFileName, service, logger);
if (tsResolvedModulesCachePath) {
void (function () { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
case 1:
_a.sent();
return [2];
}
});
}); })();
}
if (!diagnosedFiles.includes(fileName)) {
logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
doTypeChecking(configs, diagnosedFiles, fileName, service, logger);
}
if (!configs.isTestFile(fileName)) {
try {
for (var _c = __values(memoryCache.resolvedModules.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
var _e = __read(_d.value, 2), testFileName = _e[0], resolvedModules = _e[1];
if (resolvedModules.includes(fileName) &&
!diagnosedFiles.includes(testFileName) &&
fs_1.existsSync(testFileName)) {
var testFileContent = (_b = memoryCache.files.get(testFileName)) === null || _b === void 0 ? void 0 : _b.text;
if (!testFileContent) {
updateMemoryCache(cacheReadFile(testFileName), testFileName);
}
logger.debug({ testFileName: testFileName }, 'compileFn(): computing diagnostics using language service for test file which uses the module');
doTypeChecking(configs, diagnosedFiles, testFileName, service, logger);
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
}
finally { if (e_1) throw e_1.error; }
}
}
if (output.emitSkipped) {
throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
if (constants_1.TS_TSX_REGEX.test(fileName)) {
throw new Error(messages_1.interpolate("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}", { file: fileName }));
}
else {
logger.warn(messages_1.interpolate("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`", { file: fileName }));
return [code, '{}'];
}
}
if (!output.outputFiles.length) {
throw new TypeError(messages_1.interpolate("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`.", {

22
node_modules/ts-jest/dist/compiler/transpiler.js generated vendored
View File

@@ -1,32 +1,24 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.initializeTranspilerInstance = function (configs, memoryCache, logger) {
exports.initializeTranspilerInstance = void 0;
exports.initializeTranspilerInstance = function (configs, logger) {
logger.debug('initializeTranspilerInstance(): create typescript compiler');
var _a = configs.parsedTsConfig, options = _a.options, fileNames = _a.fileNames;
var options = configs.parsedTsConfig.options;
var ts = configs.compilerModule;
var program = ts.createProgram(fileNames, options);
var updateFileInCache = function (contents, filePath) {
var file = memoryCache.files.get(filePath);
if (file && file.text !== contents) {
file.version++;
file.text = contents;
}
};
return {
compileFn: function (code, fileName) {
updateFileInCache(code, fileName);
logger.debug({ fileName: fileName }, 'compileFn(): compiling as isolated module');
var result = ts.transpileModule(code, {
fileName: fileName,
transformers: configs.tsCustomTransformers,
transformers: configs.customTransformers,
compilerOptions: options,
reportDiagnostics: configs.shouldReportDiagnostic(fileName),
reportDiagnostics: configs.shouldReportDiagnostics(fileName),
});
if (result.diagnostics && configs.shouldReportDiagnostic(fileName)) {
if (result.diagnostics && configs.shouldReportDiagnostics(fileName)) {
configs.raiseDiagnostics(result.diagnostics, fileName, logger);
}
return [result.outputText, result.sourceMapText];
},
program: program,
program: undefined,
};
};

31
node_modules/ts-jest/dist/config/config-set.d.ts generated vendored
View File

@@ -1,11 +1,28 @@
import { Config } from '@jest/types';
import type { Config } from '@jest/types';
import { Logger } from 'bs-logger';
import { TsCompiler, TsJestGlobalOptions } from '../types';
import { CompilerOptions, CustomTransformers, Diagnostic, ParsedCommandLine } from 'typescript';
import type { TTypeScript } from '../types';
import type { RawCompilerOptions } from '../tsconfig-raw';
export declare class ConfigSet {
readonly parentOptions?: TsJestGlobalOptions | undefined;
get versions(): Record<string, string>;
get tsCompiler(): TsCompiler;
get tsJestDigest(): string;
private readonly parentLogger?;
readonly logger: Logger;
constructor(jestConfig: Config.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
readonly compilerModule: TTypeScript;
readonly isolatedModules: boolean;
readonly cwd: string;
tsCacheDir: string | undefined;
parsedTsConfig: ParsedCommandLine | Record<string, any>;
customTransformers: CustomTransformers;
readonly rootDir: string;
protected _overriddenCompilerOptions: Partial<CompilerOptions>;
constructor(jestConfig: Config.ProjectConfig | undefined, parentLogger?: Logger | undefined);
protected _resolveTsConfig(compilerOptions?: RawCompilerOptions, resolvedConfigFile?: string): Record<string, any>;
get tsJestDigest(): string;
isTestFile(fileName: string): boolean;
shouldStringifyContent(filePath: string): boolean;
raiseDiagnostics(diagnostics: Diagnostic[], filePath?: string, logger?: Logger): void;
shouldReportDiagnostics(filePath: string): boolean;
resolvePath(inputPath: string, { throwIfMissing, nodeResolve }?: {
throwIfMissing?: boolean;
nodeResolve?: boolean;
}): string;
}

946
node_modules/ts-jest/dist/config/config-set.js generated vendored
View File

File diff suppressed because it is too large Load Diff

10
node_modules/ts-jest/dist/config/create-jest-preset.d.ts generated vendored
View File

@@ -1,10 +0,0 @@
import { Config } from '@jest/types';
export interface TsJestPresets {
transform: Config.InitialOptions['transform'];
testMatch?: string[];
moduleFileExtensions?: string[];
}
export interface CreateJestPresetOptions {
allowJs?: boolean;
}
export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;

9
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts generated vendored
View File

@@ -1,5 +1,6 @@
import type { Config } from '@jest/types';
declare type JestPathMapping = Config.InitialOptions['moduleNameMapper'];
export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
prefix?: string | undefined;
}) => {
[key: string]: string | string[];
} | undefined;
prefix: string;
}) => JestPathMapping;
export {};

27
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js generated vendored
View File

@@ -12,14 +12,15 @@ var __values = (this && this.__values) || function(o) {
};
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.pathsToModuleNameMapper = void 0;
var bs_logger_1 = require("bs-logger");
var logger_1 = require("../util/logger");
var messages_1 = require("../util/messages");
var logger_1 = require("../utils/logger");
var messages_1 = require("../utils/messages");
var escapeRegex = function (str) { return str.replace(/[-\\^$*+?.()|[\]{}]/g, '\\$&'); };
var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'path-mapper', _a));
exports.pathsToModuleNameMapper = function (mapping, _a) {
var e_1, _b;
var _c = (_a === void 0 ? {} : _a).prefix, prefix = _c === void 0 ? '' : _c;
var _c = (_a === void 0 ? Object.create(null) : _a).prefix, prefix = _c === void 0 ? '' : _c;
var jestMap = {};
try {
for (var _d = __values(Object.keys(mapping)), _e = _d.next(); !_e.done; _e = _d.next()) {
@@ -30,25 +31,25 @@ exports.pathsToModuleNameMapper = function (mapping, _a) {
logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target.", { path: fromPath }));
continue;
}
else if (toPaths.length > 1) {
logger.warn(messages_1.interpolate("Mapping only to first target of \"{{path}}\" because it has more than one ({{count}}).", {
path: fromPath,
count: toPaths.length,
}));
}
var target = toPaths[0];
var segments = fromPath.split(/\*/g);
if (segments.length === 1) {
var paths = toPaths.map(function (target) {
var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
return "" + enrichedPrefix + target;
});
pattern = "^" + escapeRegex(fromPath) + "$";
jestMap[pattern] = "" + prefix + target;
jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
}
else if (segments.length === 2) {
var paths = toPaths.map(function (target) {
var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
return "" + enrichedPrefix + target.replace(/\*/g, '$1');
});
pattern = "^" + escapeRegex(segments[0]) + "(.*)" + escapeRegex(segments[1]) + "$";
jestMap[pattern] = "" + prefix + target.replace(/\*/g, '$1');
jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
}
else {
logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`).", { path: fromPath }));
continue;
}
}
}

5
node_modules/ts-jest/dist/constants.d.ts generated vendored
View File

@@ -1 +1,4 @@
export {};
export declare const LINE_FEED = "\n";
export declare const TS_TSX_REGEX: RegExp;
export declare const JS_JSX_REGEX: RegExp;
export declare const DECLARATION_TYPE_EXT = ".d.ts";

4
node_modules/ts-jest/dist/constants.js generated vendored
View File

@@ -1,8 +1,8 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEFAULT_JEST_TEST_MATCH = exports.DECLARATION_TYPE_EXT = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.LINE_FEED = void 0;
exports.LINE_FEED = '\n';
exports.EXTENSION_REGEX = /\.[^.]+$/;
exports.TS_TSX_REGEX = /\.tsx?$/;
exports.JS_JSX_REGEX = /\.jsx?$/;
exports.JSON_REGEX = /\.json$/i;
exports.DECLARATION_TYPE_EXT = '.d.ts';
exports.DEFAULT_JEST_TEST_MATCH = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'];

14
node_modules/ts-jest/dist/index.d.ts generated vendored
View File

@@ -1,7 +1,7 @@
import { createJestPreset as createJestPresetCore } from './config/create-jest-preset';
import { createJestPreset as createJestPresetCore } from './presets/create-jest-preset';
import { TsJestTransformer } from './ts-jest-transformer';
import { TsJestGlobalOptions } from './types';
import { mocked as mockedCore } from './util/testing';
import type { TsJestGlobalOptions } from './types';
import { mocked as mockedCore } from './utils/testing';
declare module '@jest/types' {
namespace Config {
interface ConfigGlobals {
@@ -12,12 +12,8 @@ declare module '@jest/types' {
export declare const mocked: typeof mockedCore;
export declare const createJestPreset: typeof createJestPresetCore;
export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
prefix?: string | undefined;
prefix: string;
}) => {
[key: string]: string | string[];
} | undefined;
export declare const version: string;
export declare const digest: string;
export declare function createTransformer(baseConfig?: TsJestGlobalOptions): TsJestTransformer;
declare const jestPreset: import("./config/create-jest-preset").TsJestPresets;
export { jestPreset, };
export declare function createTransformer(): TsJestTransformer;

66
node_modules/ts-jest/dist/index.js generated vendored
View File

@@ -1,36 +1,15 @@
"use strict";
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.createTransformer = exports.pathsToModuleNameMapper = exports.createJestPreset = exports.mocked = void 0;
var bs_logger_1 = require("bs-logger");
var fs_1 = require("fs");
var path_1 = require("path");
var create_jest_preset_1 = require("./config/create-jest-preset");
var create_jest_preset_1 = require("./presets/create-jest-preset");
var paths_to_module_name_mapper_1 = require("./config/paths-to-module-name-mapper");
var ts_jest_transformer_1 = require("./ts-jest-transformer");
var logger_1 = require("./util/logger");
var messages_1 = require("./util/messages");
var testing_1 = require("./util/testing");
var version_checkers_1 = require("./util/version-checkers");
var logger_1 = require("./utils/logger");
var messages_1 = require("./utils/messages");
var testing_1 = require("./utils/testing");
var version_checkers_1 = require("./utils/version-checkers");
var warn = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.warn, _a));
var helperMoved = function (name, helper) {
return warn.wrap(messages_1.interpolate("The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.", { helper: name }), helper);
@@ -38,37 +17,8 @@ var helperMoved = function (name, helper) {
exports.mocked = helperMoved('mocked', testing_1.mocked);
exports.createJestPreset = helperMoved('createJestPreset', create_jest_preset_1.createJestPreset);
exports.pathsToModuleNameMapper = helperMoved('pathsToModuleNameMapper', paths_to_module_name_mapper_1.pathsToModuleNameMapper);
exports.version = require('../package.json').version;
exports.digest = fs_1.readFileSync(path_1.resolve(__dirname, '..', '.ts-jest-digest'), 'utf8');
var transformer;
function defaultTransformer() {
return transformer || (transformer = createTransformer());
}
function createTransformer(baseConfig) {
function createTransformer() {
version_checkers_1.VersionCheckers.jest.warn();
return new ts_jest_transformer_1.TsJestTransformer(baseConfig);
return new ts_jest_transformer_1.TsJestTransformer();
}
exports.createTransformer = createTransformer;
function process() {
var _a;
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return (_a = defaultTransformer()).process.apply(_a, __spread(args));
}
exports.process = process;
function getCacheKey() {
var _a;
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return (_a = defaultTransformer()).getCacheKey.apply(_a, __spread(args));
}
exports.getCacheKey = getCacheKey;
exports.canInstrument = false;
var jestPreset = create_jest_preset_1.createJestPreset();
exports.jestPreset = jestPreset;
exports.__singleton = function () { return transformer; };
exports.__resetModule = function () { return (transformer = undefined); };

7
node_modules/ts-jest/dist/presets/create-jest-preset.d.ts generated vendored Normal file
View File

@@ -0,0 +1,7 @@
import type { Config } from '@jest/types';
import type { TsJestPresets } from '../types';
interface CreateJestPresetOptions {
allowJs?: boolean;
}
export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;
export {};

3
node_modules/ts-jest/dist/config/create-jest-preset.js → node_modules/ts-jest/dist/presets/create-jest-preset.js generated vendored
View File

@@ -11,7 +11,8 @@ var __assign = (this && this.__assign) || function () {
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var logger_1 = require("../util/logger");
exports.createJestPreset = void 0;
var logger_1 = require("../utils/logger");
var logger = logger_1.rootLogger.child({ namespace: 'jest-preset' });
function createJestPreset(_a, from) {
var _b;

70
node_modules/ts-jest/dist/transformers/hoist-jest.js generated vendored
View File

@@ -1,4 +1,15 @@
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
@@ -20,23 +31,44 @@ var __spread = (this && this.__spread) || function () {
return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.factory = exports.version = exports.name = void 0;
var bs_logger_1 = require("bs-logger");
var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
var JEST_GLOBALS_MODULE_NAME = '@jest/globals';
var JEST_GLOBAL_NAME = 'jest';
var ROOT_LEVEL_AST = 1;
exports.name = 'hoisting-jest-mock';
exports.version = 1;
exports.version = 4;
function factory(cs) {
var logger = cs.logger.child({ namespace: 'ts-hoisting' });
var ts = cs.compilerModule;
function shouldHoistExpression(expression) {
return (ts.isCallExpression(expression) &&
ts.isPropertyAccessExpression(expression.expression) &&
HOIST_METHODS.includes(expression.expression.name.text) &&
((ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === 'jest') ||
shouldHoistExpression(expression.expression.expression)));
var importNames = [];
function shouldHoistExpression(node) {
if (ts.isCallExpression(node) &&
ts.isPropertyAccessExpression(node.expression) &&
HOIST_METHODS.includes(node.expression.name.text)) {
if (importNames.length) {
return ((ts.isIdentifier(node.expression.expression) && importNames.includes(node.expression.expression.text)) ||
(ts.isPropertyAccessExpression(node.expression.expression) &&
ts.isIdentifier(node.expression.expression.expression) &&
importNames.includes(node.expression.expression.expression.text)) ||
shouldHoistExpression(node.expression.expression));
}
else {
return ((ts.isIdentifier(node.expression.expression) && node.expression.expression.text === JEST_GLOBAL_NAME) ||
shouldHoistExpression(node.expression.expression));
}
}
return false;
}
function shouldHoistNode(node) {
return ts.isExpressionStatement(node) && shouldHoistExpression(node.expression);
}
function isJestGlobalImport(node) {
return (ts.isImportDeclaration(node) &&
ts.isStringLiteral(node.moduleSpecifier) &&
node.moduleSpecifier.text === JEST_GLOBALS_MODULE_NAME);
}
function createVisitor(ctx, _) {
var level = 0;
var hoisted = [];
@@ -56,14 +88,32 @@ function factory(cs) {
}
};
var visitor = function (node) {
var _a, _b;
enter();
var resultNode = ts.visitEachChild(node, visitor, ctx);
if (isJestGlobalImport(resultNode) && ((_a = resultNode.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) &&
(ts.isNamespaceImport(resultNode.importClause.namedBindings) ||
ts.isNamedImports(resultNode.importClause.namedBindings))) {
var namedBindings = resultNode.importClause.namedBindings;
var jestImportName = ts.isNamespaceImport(namedBindings)
? namedBindings.name.text
: (_b = namedBindings.elements.find(function (element) { var _a; return element.name.text === JEST_GLOBAL_NAME || ((_a = element.propertyName) === null || _a === void 0 ? void 0 : _a.text) === JEST_GLOBAL_NAME; })) === null || _b === void 0 ? void 0 : _b.name.text;
if (jestImportName) {
importNames.push(jestImportName);
}
}
if (hoisted[level] && hoisted[level].length) {
var hoistedStmts_1 = hoisted[level];
var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s); });
var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s) && !isJestGlobalImport(s); });
var newNode = ts.getMutableClone(resultNode);
newNode.statements = ts.createNodeArray(__spread(hoistedStmts_1, otherStmts));
resultNode = newNode;
var newStatements = __spread(hoistedStmts_1, otherStmts);
if (level === ROOT_LEVEL_AST) {
var jestGlobalsImportStmts = resultNode.statements.filter(function (s) { return isJestGlobalImport(s); });
resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(__spread(jestGlobalsImportStmts, newStatements)) });
}
else {
resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(newStatements) });
}
}
exit();
if (shouldHoistNode(resultNode)) {

22
node_modules/ts-jest/dist/transformers/index.js generated vendored
View File

@@ -1,4 +1,24 @@
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var hoisting = require("./hoist-jest");
exports.internals = void 0;
var hoisting = __importStar(require("./hoist-jest"));
exports.internals = [hoisting];

3
node_modules/ts-jest/dist/transformers/path-mapping.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import type * as _ts from 'typescript';
import type { ConfigSet } from '../config/config-set';
export declare function factory(cs: ConfigSet): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;

121
node_modules/ts-jest/dist/transformers/path-mapping.js generated vendored Normal file
View File

@@ -0,0 +1,121 @@
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.factory = exports.version = exports.name = void 0;
var bs_logger_1 = require("bs-logger");
var path_1 = require("path");
exports.name = 'path-mapping';
exports.version = 1;
var isBaseDir = function (base, dir) { var _a; return !((_a = path_1.relative(base, dir)) === null || _a === void 0 ? void 0 : _a.startsWith('.')); };
function factory(cs) {
var _a;
var logger = cs.logger.child({ namespace: 'ts-path-mapping' });
var ts = cs.compilerModule;
var compilerOptions = cs.parsedTsConfig.options;
var rootDirs = (_a = compilerOptions.rootDirs) === null || _a === void 0 ? void 0 : _a.filter(path_1.isAbsolute);
var isDynamicImport = function (node) {
return ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
};
var isRequire = function (node) {
return ts.isCallExpression(node) &&
ts.isIdentifier(node.expression) &&
node.expression.text === 'require' &&
ts.isStringLiteral(node.arguments[0]) &&
node.arguments.length === 1;
};
var createVisitor = function (ctx, sf) {
var fileName = sf.fileName;
var fileDir = path_1.normalize(path_1.dirname(fileName));
var rewritePath = function (importPath) {
var e_1, _a;
var p = importPath;
var resolvedModule = ts.resolveModuleName(importPath, fileName, compilerOptions, ts.sys).resolvedModule;
if (resolvedModule) {
var resolvedFileName = resolvedModule.resolvedFileName;
var filePath = fileDir;
var modulePath = path_1.dirname(resolvedFileName);
if (rootDirs) {
var fileRootDir = '';
var moduleRootDir = '';
try {
for (var rootDirs_1 = __values(rootDirs), rootDirs_1_1 = rootDirs_1.next(); !rootDirs_1_1.done; rootDirs_1_1 = rootDirs_1.next()) {
var rootDir = rootDirs_1_1.value;
if (isBaseDir(rootDir, resolvedFileName) && rootDir.length > moduleRootDir.length)
moduleRootDir = rootDir;
if (isBaseDir(rootDir, fileName) && rootDir.length > fileRootDir.length)
fileRootDir = rootDir;
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (rootDirs_1_1 && !rootDirs_1_1.done && (_a = rootDirs_1.return)) _a.call(rootDirs_1);
}
finally { if (e_1) throw e_1.error; }
}
if (fileRootDir && moduleRootDir) {
filePath = path_1.relative(fileRootDir, filePath);
modulePath = path_1.relative(moduleRootDir, modulePath);
}
}
p = path_1.normalize(path_1.join(path_1.relative(filePath, modulePath), path_1.basename(resolvedFileName)));
p = p.startsWith('.') ? p : "./" + p;
}
return p;
};
var visitor = function (node) {
var rewrittenPath;
var newNode = ts.getMutableClone(node);
if (isDynamicImport(node) || isRequire(node)) {
rewrittenPath = rewritePath(node.arguments[0].text);
return __assign(__assign({}, newNode), { arguments: ts.createNodeArray([ts.createStringLiteral(rewrittenPath)]) });
}
if (ts.isExternalModuleReference(node) && ts.isStringLiteral(node.expression)) {
rewrittenPath = rewritePath(node.expression.text);
return ts.updateExternalModuleReference(newNode, ts.createLiteral(rewrittenPath));
}
if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
rewrittenPath = rewritePath(node.moduleSpecifier.text);
return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
}
if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
rewrittenPath = rewritePath(node.moduleSpecifier.text);
return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
}
if (ts.isImportTypeNode(node) &&
ts.isLiteralTypeNode(node.argument) &&
ts.isStringLiteral(node.argument.literal)) {
rewrittenPath = rewritePath(node.argument.literal.text);
return __assign(__assign({}, newNode), { argument: ts.createLiteralTypeNode(ts.createStringLiteral(rewrittenPath)) });
}
return ts.visitEachChild(node, visitor, ctx);
};
return visitor;
};
return function (ctx) {
var _a;
return logger.wrap((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug, _a.call = null, _a), 'visitSourceFileNode(): path mapping', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });
};
}
exports.factory = factory;

13
node_modules/ts-jest/dist/ts-jest-transformer.d.ts generated vendored
View File

@@ -1,12 +1,11 @@
import { CacheKeyOptions, TransformOptions, TransformedSource, Transformer } from '@jest/transform';
import { Config } from '@jest/types';
import type { CacheKeyOptions, TransformedSource, Transformer, TransformOptions } from '@jest/transform';
import type { Config } from '@jest/types';
import type { Logger } from 'bs-logger';
import { ConfigSet } from './config/config-set';
import { TsJestGlobalOptions } from './types';
export declare class TsJestTransformer implements Transformer {
private readonly logger;
private readonly id;
private readonly options;
constructor(baseOptions?: TsJestGlobalOptions);
protected readonly logger: Logger;
protected _transformCfgStr: string;
constructor();
configsFor(jestConfig: Config.ProjectConfig): ConfigSet;
process(input: string, filePath: Config.Path, jestConfig: Config.ProjectConfig, transformOptions?: TransformOptions): TransformedSource | string;
getCacheKey(fileContent: string, filePath: string, _jestConfigStr: string, transformOptions: CacheKeyOptions): string;

99
node_modules/ts-jest/dist/ts-jest-transformer.js generated vendored
View File

@@ -11,53 +11,53 @@ var __assign = (this && this.__assign) || function () {
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require("util");
exports.TsJestTransformer = void 0;
var config_set_1 = require("./config/config-set");
var constants_1 = require("./constants");
var json_1 = require("./util/json");
var jsonable_value_1 = require("./util/jsonable-value");
var logger_1 = require("./util/logger");
var messages_1 = require("./util/messages");
var sha1_1 = require("./util/sha1");
var INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
var json_1 = require("./utils/json");
var jsonable_value_1 = require("./utils/jsonable-value");
var logger_1 = require("./utils/logger");
var messages_1 = require("./utils/messages");
var sha1_1 = require("./utils/sha1");
var TsJestTransformer = (function () {
function TsJestTransformer(baseOptions) {
if (baseOptions === void 0) { baseOptions = {}; }
this.options = __assign({}, baseOptions);
this.id = TsJestTransformer._nextTransformerId;
this.logger = logger_1.rootLogger.child({
transformerId: this.id,
namespace: 'jest-transformer',
});
this.logger.debug({ baseOptions: baseOptions }, 'created new transformer');
function TsJestTransformer() {
this.logger = logger_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
this.logger.debug('created new transformer');
}
Object.defineProperty(TsJestTransformer, "_nextTransformerId", {
get: function () {
return ++TsJestTransformer._lastTransformerId;
},
enumerable: true,
configurable: true
});
TsJestTransformer.prototype[INSPECT_CUSTOM] = function () {
return "[object TsJestTransformer<#" + this.id + ">]";
};
TsJestTransformer.prototype.configsFor = function (jestConfig) {
var csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.value === jestConfig; });
if (csi)
return csi.configSet;
var serialized = json_1.stringify(jestConfig);
csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.serialized === serialized; });
if (csi) {
csi.jestConfig.value = jestConfig;
return csi.configSet;
var ccs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.value === jestConfig; });
var configSet;
if (ccs) {
this._transformCfgStr = ccs.transformerCfgStr;
configSet = ccs.configSet;
}
else {
var serializedJestCfg_1 = json_1.stringify(jestConfig);
var serializedCcs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.serialized === serializedJestCfg_1; });
if (serializedCcs) {
serializedCcs.jestConfig.value = jestConfig;
this._transformCfgStr = serializedCcs.transformerCfgStr;
configSet = serializedCcs.configSet;
}
else {
this.logger.info('no matching config-set found, creating a new one');
configSet = new config_set_1.ConfigSet(jestConfig);
var jest_1 = __assign({}, jestConfig);
var globals = (jest_1.globals = __assign({}, jest_1.globals));
jest_1.name = undefined;
jest_1.cacheDirectory = undefined;
delete globals['ts-jest'];
this._transformCfgStr = new jsonable_value_1.JsonableValue(__assign(__assign({ digest: configSet.tsJestDigest, babel: configSet.babelConfig }, jest_1), { tsconfig: {
options: configSet.parsedTsConfig.options,
raw: configSet.parsedTsConfig.raw,
} })).serialized;
TsJestTransformer._cachedConfigSets.push({
jestConfig: new jsonable_value_1.JsonableValue(jestConfig),
configSet: configSet,
transformerCfgStr: this._transformCfgStr,
});
}
}
var jestConfigObj = jestConfig;
this.logger.info('no matching config-set found, creating a new one');
var configSet = new config_set_1.ConfigSet(jestConfigObj, this.options, this.logger);
TsJestTransformer._configSetsIndex.push({
jestConfig: new jsonable_value_1.JsonableValue(jestConfigObj),
configSet: configSet,
});
return configSet;
};
TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
@@ -66,13 +66,13 @@ var TsJestTransformer = (function () {
var source = input;
var configs = this.configsFor(jestConfig);
var hooks = configs.hooks;
var stringify = configs.shouldStringifyContent(filePath);
var babelJest = stringify ? undefined : configs.babelJestTransformer;
var isDefinitionFile = filePath.endsWith('.d.ts');
var shouldStringifyContent = configs.shouldStringifyContent(filePath);
var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
var isDefinitionFile = filePath.endsWith(constants_1.DECLARATION_TYPE_EXT);
var isJsFile = constants_1.JS_JSX_REGEX.test(filePath);
var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(filePath);
if (stringify) {
result = "module.exports=" + JSON.stringify(source);
if (shouldStringifyContent) {
result = "module.exports=" + json_1.stringify(source);
}
else if (isDefinitionFile) {
result = '';
@@ -103,13 +103,12 @@ var TsJestTransformer = (function () {
return result;
};
TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, _jestConfigStr, transformOptions) {
this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
var configs = this.configsFor(transformOptions.config);
this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? configs.rootDir : _b;
return sha1_1.sha1(configs.cacheKey, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
return sha1_1.sha1(this._transformCfgStr, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
};
TsJestTransformer._configSetsIndex = [];
TsJestTransformer._lastTransformerId = 0;
TsJestTransformer._cachedConfigSets = [];
return TsJestTransformer;
}());
exports.TsJestTransformer = TsJestTransformer;

105
node_modules/ts-jest/dist/tsconfig-raw.d.ts generated vendored Normal file
View File

@@ -0,0 +1,105 @@
export interface RawCompilerOptions {
charset?: string;
composite?: boolean;
declaration?: boolean;
declarationDir?: string | null;
diagnostics?: boolean;
disableReferencedProjectLoad?: boolean;
emitBOM?: boolean;
emitDeclarationOnly?: boolean;
incremental?: boolean;
tsBuildInfoFile?: string;
inlineSourceMap?: boolean;
inlineSources?: boolean;
jsx?: 'preserve' | 'react' | 'react-jsx' | 'react-jsxdev' | 'react-native';
reactNamespace?: string;
jsxFactory?: string;
jsxFragmentFactory?: string;
jsxImportSource?: string;
listFiles?: boolean;
mapRoot?: string;
module?: 'CommonJS' | 'AMD' | 'System' | 'UMD' | 'ES6' | 'ES2015' | 'ES2020' | 'ESNext' | 'None' | string;
moduleResolution?: 'Classic' | 'Node';
newLine?: 'crlf' | 'lf';
noEmit?: boolean;
noEmitHelpers?: boolean;
noEmitOnError?: boolean;
noImplicitAny?: boolean;
noImplicitThis?: boolean;
noUnusedLocals?: boolean;
noUnusedParameters?: boolean;
noLib?: boolean;
noResolve?: boolean;
noStrictGenericChecks?: boolean;
skipDefaultLibCheck?: boolean;
skipLibCheck?: boolean;
outFile?: string;
outDir?: string;
preserveConstEnums?: boolean;
preserveSymlinks?: boolean;
preserveWatchOutput?: boolean;
pretty?: boolean;
removeComments?: boolean;
rootDir?: string;
isolatedModules?: boolean;
sourceMap?: boolean;
sourceRoot?: string;
suppressExcessPropertyErrors?: boolean;
suppressImplicitAnyIndexErrors?: boolean;
target?: 'ES3' | 'ES5' | 'ES6' | 'ES2015' | 'ES2016' | 'ES2017' | 'ES2018' | 'ES2019' | 'ES2020' | 'ESNext' | string;
watch?: boolean;
fallbackPolling?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling';
watchDirectory?: 'useFsEvents' | 'fixedPollingInterval' | 'dynamicPriorityPolling';
watchFile?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling' | 'useFsEvents' | 'useFsEventsOnParentDirectory';
experimentalDecorators?: boolean;
emitDecoratorMetadata?: boolean;
allowUnusedLabels?: boolean;
noImplicitReturns?: boolean;
noUncheckedIndexedAccess?: boolean;
noFallthroughCasesInSwitch?: boolean;
allowUnreachableCode?: boolean;
forceConsistentCasingInFileNames?: boolean;
generateCpuProfile?: string;
baseUrl?: string;
paths?: {
[k: string]: string[];
};
plugins?: {
name?: string;
[k: string]: unknown;
}[];
rootDirs?: string[];
typeRoots?: string[];
types?: string[];
traceResolution?: boolean;
allowJs?: boolean;
noErrorTruncation?: boolean;
allowSyntheticDefaultImports?: boolean;
noImplicitUseStrict?: boolean;
listEmittedFiles?: boolean;
disableSizeLimit?: boolean;
lib?: ('ES5' | 'ES6' | 'ES2015' | 'ES2015.Collection' | 'ES2015.Core' | 'ES2015.Generator' | 'ES2015.Iterable' | 'ES2015.Promise' | 'ES2015.Proxy' | 'ES2015.Reflect' | 'ES2015.Symbol.WellKnown' | 'ES2015.Symbol' | 'ES2016' | 'ES2016.Array.Include' | 'ES2017' | 'ES2017.Intl' | 'ES2017.Object' | 'ES2017.SharedMemory' | 'ES2017.String' | 'ES2017.TypedArrays' | 'ES2018' | 'ES2018.AsyncGenerator' | 'ES2018.AsyncIterable' | 'ES2018.Intl' | 'ES2018.Promise' | 'ES2018.Regexp' | 'ES2019' | 'ES2019.Array' | 'ES2019.Object' | 'ES2019.String' | 'ES2019.Symbol' | 'ES2020' | 'ES2020.BigInt' | 'ES2020.Promise' | 'ES2020.String' | 'ES2020.Symbol.WellKnown' | 'ESNext' | 'ESNext.Array' | 'ESNext.AsyncIterable' | 'ESNext.BigInt' | 'ESNext.Intl' | 'ESNext.Promise' | 'ESNext.String' | 'ESNext.Symbol' | 'DOM' | 'DOM.Iterable' | 'ScriptHost' | 'WebWorker' | 'WebWorker.ImportScripts')[];
strictNullChecks?: boolean;
maxNodeModuleJsDepth?: number;
importHelpers?: boolean;
importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';
alwaysStrict?: boolean;
strict?: boolean;
strictBindCallApply?: boolean;
downlevelIteration?: boolean;
checkJs?: boolean;
strictFunctionTypes?: boolean;
strictPropertyInitialization?: boolean;
esModuleInterop?: boolean;
allowUmdGlobalAccess?: boolean;
keyofStringsOnly?: boolean;
useDefineForClassFields?: boolean;
declarationMap?: boolean;
resolveJsonModule?: boolean;
assumeChangesOnlyAffectDirectDependencies?: boolean;
extendedDiagnostics?: boolean;
listFilesOnly?: boolean;
disableSourceOfProjectReferenceRedirect?: boolean;
disableSolutionSearching?: boolean;
[k: string]: unknown;
}

2
node_modules/ts-jest/dist/tsconfig-raw.js generated vendored Normal file
View File

@@ -0,0 +1,2 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

80
node_modules/ts-jest/dist/types.d.ts generated vendored
View File

@@ -1,76 +1,50 @@
import * as _ts from 'typescript';
import type { Config } from '@jest/types';
import type * as _babel from 'babel__core';
import type * as _ts from 'typescript';
import type { RawCompilerOptions } from './tsconfig-raw';
export declare type TTypeScript = typeof _ts;
export declare type BabelConfig = _babel.TransformOptions;
export interface AstTransformer<T = Record<string, unknown>> {
path: string;
options?: T;
}
export interface ConfigCustomTransformer {
before?: (string | AstTransformer)[];
after?: (string | AstTransformer)[];
afterDeclarations?: (string | AstTransformer)[];
}
export interface TsJestGlobalOptions {
tsConfig?: boolean | string | _ts.CompilerOptions;
tsconfig?: boolean | string | _ts.CompilerOptions;
packageJson?: boolean | string | object;
tsConfig?: boolean | string | RawCompilerOptions;
tsconfig?: boolean | string | RawCompilerOptions;
packageJson?: boolean | string | Record<string, unknown>;
isolatedModules?: boolean;
compiler?: string;
astTransformers?: string[];
astTransformers?: string[] | ConfigCustomTransformer;
diagnostics?: boolean | {
pretty?: boolean;
ignoreCodes?: number | string | (number | string)[];
pathRegex?: RegExp | string;
exclude?: Config.Glob[];
warnOnly?: boolean;
};
babelConfig?: boolean | string | BabelConfig;
stringifyContentPathRegex?: string | RegExp;
}
interface TsJestConfig$tsConfig$file {
kind: 'file';
value: string | undefined;
export interface GlobalConfigTsJest extends Config.ConfigGlobals {
'ts-jest': TsJestGlobalOptions;
}
interface TsJestConfig$tsConfig$inline {
kind: 'inline';
value: _ts.CompilerOptions;
export interface InitialOptionsTsJest extends Config.InitialOptions {
globals?: GlobalConfigTsJest;
}
declare type TsJestConfig$tsConfig = TsJestConfig$tsConfig$file | TsJestConfig$tsConfig$inline | undefined;
interface TsJestConfig$diagnostics {
export declare type TsJestPresets = Pick<Config.InitialOptions, 'moduleFileExtensions' | 'transform' | 'testMatch'>;
export interface TsJestDiagnosticsCfg {
pretty: boolean;
ignoreCodes: number[];
pathRegex?: string | undefined;
exclude: Config.Glob[];
throws: boolean;
warnOnly?: boolean;
}
interface TsJestConfig$babelConfig$file {
kind: 'file';
value: string | undefined;
}
interface TsJestConfig$babelConfig$inline {
kind: 'inline';
value: BabelConfig;
}
declare type TsJestConfig$babelConfig = TsJestConfig$babelConfig$file | TsJestConfig$babelConfig$inline | undefined;
interface TsJestConfig$packageJson$file {
kind: 'file';
value: string | undefined;
}
interface TsJestConfig$packageJson$inline {
kind: 'inline';
value: any;
}
declare type TsJestConfig$packageJson = TsJestConfig$packageJson$file | TsJestConfig$packageJson$inline | undefined;
declare type TsJestConfig$stringifyContentPathRegex = string | undefined;
export interface TsJestConfig {
tsConfig: TsJestConfig$tsConfig;
packageJson: TsJestConfig$packageJson;
isolatedModules: boolean;
compiler: string;
diagnostics: TsJestConfig$diagnostics;
babelConfig: TsJestConfig$babelConfig;
transformers: string[];
stringifyContentPathRegex: TsJestConfig$stringifyContentPathRegex;
}
export interface TsCompiler {
program: _ts.Program | undefined;
}
export declare type TSFiles = Map<string, TSFile>;
export interface TSFile {
text?: string;
output?: string;
version: number;
projectReference?: {
project?: _ts.ResolvedProjectReference;
outputFileName?: string;
};
}
export {};

3
node_modules/ts-jest/dist/util/exported.d.ts generated vendored
View File

@@ -1,3 +0,0 @@
export { mocked } from './testing';
export { createJestPreset } from '../config/create-jest-preset';
export { pathsToModuleNameMapper } from '../config/paths-to-module-name-mapper';

8
node_modules/ts-jest/dist/util/exported.js generated vendored
View File

@@ -1,8 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var testing_1 = require("./testing");
exports.mocked = testing_1.mocked;
var create_jest_preset_1 = require("../config/create-jest-preset");
exports.createJestPreset = create_jest_preset_1.createJestPreset;
var paths_to_module_name_mapper_1 = require("../config/paths-to-module-name-mapper");
exports.pathsToModuleNameMapper = paths_to_module_name_mapper_1.pathsToModuleNameMapper;

1
node_modules/ts-jest/dist/util/json.d.ts generated vendored
View File

@@ -1 +0,0 @@
export {};

1
node_modules/ts-jest/dist/util/jsonable-value.d.ts generated vendored
View File

@@ -1 +0,0 @@
export {};

1
node_modules/ts-jest/dist/util/logger.d.ts generated vendored
View File

@@ -1 +0,0 @@
export {};

56
node_modules/ts-jest/dist/util/version-checkers.js generated vendored
View File

@@ -1,56 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var semver_1 = require("semver");
var get_package_version_1 = require("./get-package-version");
var logger_1 = require("./logger");
var messages_1 = require("./messages");
var logger = logger_1.rootLogger.child({ namespace: 'versions' });
exports.VersionCheckers = {
jest: createVersionChecker('jest', ">=25 <26"),
typescript: createVersionChecker('typescript', ">=3.4 <4"),
babelJest: createVersionChecker('babel-jest', ">=25 <26"),
babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8"),
};
function checkVersion(name, expectedRange, action) {
if (action === void 0) { action = 'warn'; }
var version = get_package_version_1.getPackageVersion(name);
var success = !!version && semver_1.satisfies(version, expectedRange);
logger.debug({
actualVersion: version,
expectedVersion: expectedRange,
}, 'checking version of %s: %s', name, success ? 'OK' : 'NOT OK');
if (!action || success)
return success;
var message = messages_1.interpolate(version ? "Version {{actualVersion}} of {{module}} installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version ({{expectedVersion}}). Please do not report issues in ts-jest if you are using unsupported versions." : "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}}).", {
module: name,
actualVersion: version || '??',
expectedVersion: rangeToHumanString(expectedRange),
});
if (action === 'warn') {
logger.warn(message);
}
else if (action === 'throw') {
logger.fatal(message);
throw new RangeError(message);
}
return success;
}
function rangeToHumanString(versionRange) {
return new semver_1.Range(versionRange).toString();
}
function createVersionChecker(moduleName, expectedVersion) {
var memo;
var warn = function () {
if (memo !== undefined)
return memo;
return (memo = checkVersion(moduleName, expectedVersion, 'warn'));
};
var raise = function () { return checkVersion(moduleName, expectedVersion, 'throw'); };
return {
raise: raise,
warn: warn,
forget: function () {
memo = undefined;
},
};
}

0
node_modules/ts-jest/dist/util/backports.d.ts → node_modules/ts-jest/dist/utils/backports.d.ts generated vendored
View File

9
node_modules/ts-jest/dist/util/backports.js → node_modules/ts-jest/dist/utils/backports.js generated vendored
View File

@@ -12,13 +12,16 @@ var __assign = (this && this.__assign) || function () {
};
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.backportTsJestDebugEnvVar = exports.backportJestConfig = void 0;
var bs_logger_1 = require("bs-logger");
var messages_1 = require("./messages");
var constants_1 = require("../constants");
var context = (_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'backports', _a);
exports.backportJestConfig = function (logger, config) {
var _a, _b;
logger.debug(__assign(__assign({}, context), { config: config }), 'backporting config');
var _a = (config || {}).globals, globals = _a === void 0 ? {} : _a;
var _b = globals["ts-jest"], tsJest = _b === void 0 ? {} : _b;
var _c = (config || {}).globals, globals = _c === void 0 ? {} : _c;
var _d = globals["ts-jest"], tsJest = _d === void 0 ? {} : _d;
var mergeTsJest = {};
var hadWarnings = false;
var warnConfig = function (oldPath, newPath, note) {
@@ -84,7 +87,7 @@ exports.backportJestConfig = function (logger, config) {
if (hadWarnings) {
logger.warn(context, "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.");
}
return __assign(__assign({}, config), { globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
return __assign(__assign({}, config), { testMatch: (_a = config.testMatch) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_JEST_TEST_MATCH, testRegex: (_b = config.testRegex) !== null && _b !== void 0 ? _b : [], globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
};
exports.backportTsJestDebugEnvVar = function (logger) {
if ('TS_JEST_DEBUG' in process.env) {

0
node_modules/ts-jest/dist/util/get-package-version.d.ts → node_modules/ts-jest/dist/utils/get-package-version.d.ts generated vendored
View File

1
node_modules/ts-jest/dist/util/get-package-version.js → node_modules/ts-jest/dist/utils/get-package-version.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getPackageVersion = void 0;
function getPackageVersion(moduleName) {
try {
return require(moduleName + "/package.json").version;

0
node_modules/ts-jest/dist/util/importer.d.ts → node_modules/ts-jest/dist/utils/importer.d.ts generated vendored
View File

3
node_modules/ts-jest/dist/util/importer.js → node_modules/ts-jest/dist/utils/importer.js generated vendored
View File

@@ -37,6 +37,7 @@ var __spread = (this && this.__spread) || function () {
return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.__requireModule = exports.importer = exports.Importer = void 0;
var logger_1 = require("./logger");
var memoize_1 = require("./memoize");
var messages_1 = require("./messages");
@@ -61,7 +62,7 @@ var Importer = (function () {
jest: [passThru(version_checkers_1.VersionCheckers.jest.warn)],
});
},
enumerable: true,
enumerable: false,
configurable: true
});
Importer.prototype.babelJest = function (why) {

2
node_modules/ts-jest/dist/utils/json.d.ts generated vendored Normal file
View File

@@ -0,0 +1,2 @@
export declare function stringify(input: unknown): string;
export declare function parse(input: string): any;

1
node_modules/ts-jest/dist/util/json.js → node_modules/ts-jest/dist/utils/json.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.normalize = exports.parse = exports.stringify = void 0;
var stableStringify = require("fast-json-stable-stringify");
var UNDEFINED = 'undefined';
function stringify(input) {

10
node_modules/ts-jest/dist/utils/jsonable-value.d.ts generated vendored Normal file
View File

@@ -0,0 +1,10 @@
export declare class JsonableValue<V = Record<string, any>> {
private _serialized;
private _value;
constructor(value: V);
set value(value: V);
get value(): V;
get serialized(): string;
valueOf(): V;
toString(): string;
}

5
node_modules/ts-jest/dist/util/jsonable-value.js → node_modules/ts-jest/dist/utils/jsonable-value.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JsonableValue = void 0;
var json_1 = require("./json");
var JsonableValue = (function () {
function JsonableValue(value) {
@@ -13,14 +14,14 @@ var JsonableValue = (function () {
this._value = value;
this._serialized = json_1.stringify(value);
},
enumerable: true,
enumerable: false,
configurable: true
});
Object.defineProperty(JsonableValue.prototype, "serialized", {
get: function () {
return this._serialized;
},
enumerable: true,
enumerable: false,
configurable: true
});
JsonableValue.prototype.valueOf = function () {

1
node_modules/ts-jest/dist/utils/logger.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export declare let rootLogger: import("bs-logger/dist/logger").Logger;

1
node_modules/ts-jest/dist/util/logger.js → node_modules/ts-jest/dist/utils/logger.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.rootLogger = void 0;
var bs_logger_1 = require("bs-logger");
var backports_1 = require("./backports");
var original = process.env.TS_JEST_LOG;

0
node_modules/ts-jest/dist/util/memoize.d.ts → node_modules/ts-jest/dist/utils/memoize.d.ts generated vendored
View File

1
node_modules/ts-jest/dist/util/memoize.js → node_modules/ts-jest/dist/utils/memoize.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Memoize = void 0;
var cacheProp = Symbol.for('[memoize]');
function Memoize(keyBuilder) {
return function (_, propertyKey, descriptor) {

0
node_modules/ts-jest/dist/util/messages.d.ts → node_modules/ts-jest/dist/utils/messages.d.ts generated vendored
View File

1
node_modules/ts-jest/dist/util/messages.js → node_modules/ts-jest/dist/utils/messages.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.interpolate = void 0;
function interpolate(msg, vars) {
if (vars === void 0) { vars = {}; }
return msg.replace(/\{\{([^\}]+)\}\}/g, function (_, key) { return (key in vars ? vars[key] : _); });

0
node_modules/ts-jest/dist/util/normalize-slashes.d.ts → node_modules/ts-jest/dist/utils/normalize-slashes.d.ts generated vendored
View File

1
node_modules/ts-jest/dist/util/normalize-slashes.js → node_modules/ts-jest/dist/utils/normalize-slashes.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.normalizeSlashes = void 0;
function normalizeSlashes(value) {
return value.replace(/\\/g, '/');
}

0
node_modules/ts-jest/dist/util/sha1.d.ts → node_modules/ts-jest/dist/utils/sha1.d.ts generated vendored
View File

1
node_modules/ts-jest/dist/util/sha1.js → node_modules/ts-jest/dist/utils/sha1.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sha1 = exports.cache = void 0;
var crypto_1 = require("crypto");
exports.cache = Object.create(null);
function sha1() {

23
node_modules/ts-jest/dist/util/testing.d.ts → node_modules/ts-jest/dist/utils/testing.d.ts generated vendored
View File

@@ -1,28 +1,28 @@
/// <reference types="jest" />
declare type MockableFunction = (...args: any[]) => any;
declare type MethodKeysOf<T> = {
export declare type MockableFunction = (...args: any[]) => any;
export declare type MethodKeysOf<T> = {
[K in keyof T]: T[K] extends MockableFunction ? K : never;
}[keyof T];
declare type PropertyKeysOf<T> = {
export declare type PropertyKeysOf<T> = {
[K in keyof T]: T[K] extends MockableFunction ? never : K;
}[keyof T];
declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
export declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
export declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
export interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
new (...args: ConstructorArgumentsOf<T>): T;
(...args: ArgumentsOf<T>): ReturnType<T>;
}
declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : {};
declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
export declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : T;
export declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
[K in keyof T]: T[K];
};
declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
declare type MockedObject<T> = MaybeMockedConstructor<T> & {
export declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
export declare type MockedObject<T> = MaybeMockedConstructor<T> & {
[K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
} & {
[K in PropertyKeysOf<T>]: T[K];
};
declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
export declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
[K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunctionDeep<T[K]> : T[K];
} & {
[K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]>;
@@ -31,4 +31,3 @@ export declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunc
export declare type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
export declare function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
export declare function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
export {};

1
node_modules/ts-jest/dist/util/testing.js → node_modules/ts-jest/dist/utils/testing.js generated vendored
View File

@@ -1,5 +1,6 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.mocked = void 0;
function mocked(item, _deep) {
if (_deep === void 0) { _deep = false; }
return item;

0
node_modules/ts-jest/dist/util/ts-error.d.ts → node_modules/ts-jest/dist/utils/ts-error.d.ts generated vendored
View File

3
node_modules/ts-jest/dist/util/ts-error.js → node_modules/ts-jest/dist/utils/ts-error.js generated vendored
View File

@@ -3,7 +3,7 @@ var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
@@ -13,6 +13,7 @@ var __extends = (this && this.__extends) || (function () {
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.TSError = exports.INSPECT_CUSTOM = void 0;
var make_error_1 = require("make-error");
var util_1 = require("util");
var logger_1 = require("./logger");

0
node_modules/ts-jest/dist/util/version-checkers.d.ts → node_modules/ts-jest/dist/utils/version-checkers.d.ts generated vendored
View File

60
node_modules/ts-jest/dist/utils/version-checkers.js generated vendored Normal file
View File

@@ -0,0 +1,60 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.VersionCheckers = void 0;
var semver_1 = require("semver");
var get_package_version_1 = require("./get-package-version");
var logger_1 = require("./logger");
var messages_1 = require("./messages");
var logger = logger_1.rootLogger.child({ namespace: 'versions' });
exports.VersionCheckers = {
jest: createVersionChecker('jest', ">=26 <27"),
typescript: createVersionChecker('typescript', ">=3.8 <5"),
babelJest: createVersionChecker('babel-jest', ">=26 <27"),
babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8"),
};
function checkVersion(name, expectedRange, action) {
if (action === void 0) { action = 'warn'; }
var success = true;
if (!('TS_JEST_DISABLE_VER_CHECKER' in process.env)) {
var version = get_package_version_1.getPackageVersion(name);
success = !!version && semver_1.satisfies(version, expectedRange);
logger.debug({
actualVersion: version,
expectedVersion: expectedRange,
}, 'checking version of %s: %s', name, success ? 'OK' : 'NOT OK');
if (!action || success)
return success;
var message = messages_1.interpolate(version ? "Version {{actualVersion}} of {{module}} installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version ({{expectedVersion}}). Please do not report issues in ts-jest if you are using unsupported versions." : "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}}).", {
module: name,
actualVersion: version || '??',
expectedVersion: rangeToHumanString(expectedRange),
});
if (action === 'warn') {
logger.warn(message);
}
else if (action === 'throw') {
logger.fatal(message);
throw new RangeError(message);
}
}
return success;
}
function rangeToHumanString(versionRange) {
return new semver_1.Range(versionRange).toString();
}
function createVersionChecker(moduleName, expectedVersion) {
var memo;
var warn = function () {
if (memo !== undefined)
return memo;
return (memo = checkVersion(moduleName, expectedVersion, 'warn'));
};
var raise = function () { return checkVersion(moduleName, expectedVersion, 'throw'); };
return {
raise: raise,
warn: warn,
forget: function () {
memo = undefined;
},
};
}