Add node modules and compiled JavaScript from main (#57)
Co-authored-by: Oliver King <oking3@uncc.edu>
This commit is contained in:
github-actions[bot]
GitHub
parent
d893f27da9
commit
7f7e5ba5ea
6750 changed files with 1745644 additions and 10860 deletions
1
node_modules/ts-jest/dist/cli/config/init.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/cli/config/init.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
154
node_modules/ts-jest/dist/cli/config/init.js
generated
vendored
Normal file
154
node_modules/ts-jest/dist/cli/config/init.js
generated
vendored
Normal file
|
|
@ -0,0 +1,154 @@
|
|||
"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 __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 };
|
||||
}
|
||||
};
|
||||
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;
|
||||
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';
|
||||
exists = fs_1.existsSync(filePath);
|
||||
pkgFile = isPackage ? filePath : path_1.join(process.cwd(), 'package.json');
|
||||
hasPackage = isPackage || fs_1.existsSync(pkgFile);
|
||||
_a = args.jestPreset, jestPreset = _a === void 0 ? true : _a, askedTsconfig = args.tsconfig, force = args.force, jsdom = args.jsdom;
|
||||
tsconfig = askedTsconfig === 'tsconfig.json' ? undefined : askedTsconfig;
|
||||
pkgJson = hasPackage ? JSON.parse(fs_1.readFileSync(pkgFile, 'utf8')) : {};
|
||||
jsFilesProcessor = args.js, shouldPostProcessWithBabel = args.babel;
|
||||
if (jsFilesProcessor == null) {
|
||||
jsFilesProcessor = shouldPostProcessWithBabel ? 'babel' : undefined;
|
||||
}
|
||||
else if (shouldPostProcessWithBabel == null) {
|
||||
shouldPostProcessWithBabel = jsFilesProcessor === 'babel';
|
||||
}
|
||||
if (jsFilesProcessor === 'babel') {
|
||||
preset = presets_1.jsWIthBabel;
|
||||
}
|
||||
else if (jsFilesProcessor === 'ts') {
|
||||
preset = presets_1.jsWithTs;
|
||||
}
|
||||
else {
|
||||
preset = presets_1.defaults;
|
||||
}
|
||||
if (isPackage && !exists) {
|
||||
throw new Error("File " + file + " does not exists.");
|
||||
}
|
||||
else if (!isPackage && exists && !force) {
|
||||
throw new Error("Configuration file " + file + " already exists.");
|
||||
}
|
||||
if (!isPackage && !name.endsWith('.js')) {
|
||||
throw new TypeError("Configuration file " + file + " must be a .js file or the package.json.");
|
||||
}
|
||||
if (hasPackage && pkgJson.jest) {
|
||||
if (force && !isPackage) {
|
||||
delete pkgJson.jest;
|
||||
fs_1.writeFileSync(pkgFile, JSON.stringify(pkgJson, undefined, ' '));
|
||||
}
|
||||
else if (!force) {
|
||||
throw new Error("A Jest configuration is already set in " + pkgFile + ".");
|
||||
}
|
||||
}
|
||||
if (isPackage) {
|
||||
base = jestPreset ? { preset: preset.name } : __assign({}, preset.value);
|
||||
if (!jsdom)
|
||||
base.testEnvironment = 'node';
|
||||
if (tsconfig || shouldPostProcessWithBabel) {
|
||||
tsJestConf = {};
|
||||
base.globals = { 'ts-jest': tsJestConf };
|
||||
if (tsconfig)
|
||||
tsJestConf.tsconfig = tsconfig;
|
||||
if (shouldPostProcessWithBabel)
|
||||
tsJestConf.babelConfig = true;
|
||||
}
|
||||
body = JSON.stringify(__assign(__assign({}, pkgJson), { jest: base }), undefined, ' ');
|
||||
}
|
||||
else {
|
||||
content = [];
|
||||
if (!jestPreset) {
|
||||
content.push(preset.jsImport('tsjPreset') + ";", '');
|
||||
}
|
||||
content.push('module.exports = {');
|
||||
if (jestPreset) {
|
||||
content.push(" preset: '" + preset.name + "',");
|
||||
}
|
||||
else {
|
||||
content.push(' ...tsjPreset,');
|
||||
}
|
||||
if (!jsdom)
|
||||
content.push(" testEnvironment: 'node',");
|
||||
if (tsconfig || shouldPostProcessWithBabel) {
|
||||
content.push(' globals: {');
|
||||
content.push(" 'ts-jest': {");
|
||||
if (tsconfig)
|
||||
content.push(" tsconfig: " + json5_1.stringify(tsconfig) + ",");
|
||||
if (shouldPostProcessWithBabel)
|
||||
content.push(' babelConfig: true,');
|
||||
content.push(' },');
|
||||
content.push(' },');
|
||||
}
|
||||
content.push('};');
|
||||
body = content.join('\n');
|
||||
}
|
||||
fs_1.writeFileSync(filePath, body);
|
||||
process.stderr.write("\nJest configuration written to \"" + filePath + "\".\n");
|
||||
return [2];
|
||||
});
|
||||
}); };
|
||||
exports.help = function () { return __awaiter(void 0, void 0, void 0, function () {
|
||||
return __generator(this, function (_a) {
|
||||
process.stdout.write("\nUsage:\n ts-jest config:init [options] [<config-file>]\n\nArguments:\n <config-file> Can be a js or json Jest config file. If it is a\n package.json file, the configuration will be read from\n the \"jest\" property.\n Default: jest.config.js\n\nOptions:\n --force Discard any existing Jest config\n --js ts|babel Process .js files with ts-jest if 'ts' or with\n babel-jest if 'babel'\n --no-jest-preset Disable the use of Jest presets\n --tsconfig <file> Path to the tsconfig.json file\n --babel Pipe babel-jest after ts-jest\n --jsdom Use jsdom as test environment instead of node\n");
|
||||
return [2];
|
||||
});
|
||||
}); };
|
||||
1
node_modules/ts-jest/dist/cli/config/migrate.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/cli/config/migrate.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
219
node_modules/ts-jest/dist/cli/config/migrate.js
generated
vendored
Normal file
219
node_modules/ts-jest/dist/cli/config/migrate.js
generated
vendored
Normal file
|
|
@ -0,0 +1,219 @@
|
|||
"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;
|
||||
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;
|
||||
};
|
||||
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("../../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;
|
||||
var _a;
|
||||
return __generator(this, function (_b) {
|
||||
nullLogger = bs_logger_1.createLogger({ targets: [] });
|
||||
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)) {
|
||||
throw new Error("Configuration file " + file + " does not exists.");
|
||||
}
|
||||
name = path_1.basename(file);
|
||||
isPackage = name === 'package.json';
|
||||
if (!/\.(js|json)$/.test(name)) {
|
||||
throw new TypeError("Configuration file " + file + " must be a JavaScript or JSON file.");
|
||||
}
|
||||
actualConfig = require(filePath);
|
||||
if (isPackage) {
|
||||
actualConfig = actualConfig.jest;
|
||||
}
|
||||
if (!actualConfig)
|
||||
actualConfig = {};
|
||||
migratedConfig = backports_1.backportJestConfig(nullLogger, actualConfig);
|
||||
if (!migratedConfig.preset && args.jestPreset) {
|
||||
if (args.js) {
|
||||
presetName = args.js === 'babel' ? "ts-jest/presets/js-with-babel" : "ts-jest/presets/js-with-ts";
|
||||
}
|
||||
else {
|
||||
jsTransformers = Object.keys(migratedConfig.transform || {}).reduce(function (list, pattern) {
|
||||
if (RegExp(pattern.replace(/^<rootDir>\/?/, '/dummy-project/')).test('/dummy-project/src/foo.js')) {
|
||||
var transformer = migratedConfig.transform[pattern];
|
||||
if (/\bbabel-jest\b/.test(transformer))
|
||||
transformer = 'babel-jest';
|
||||
else if (/\ts-jest\b/.test(transformer))
|
||||
transformer = 'ts-jest';
|
||||
return __spread(list, [transformer]);
|
||||
}
|
||||
return list;
|
||||
}, []);
|
||||
jsWithTs = jsTransformers.includes('ts-jest');
|
||||
jsWithBabel = jsTransformers.includes('babel-jest');
|
||||
if (jsWithBabel && !jsWithTs) {
|
||||
presetName = "ts-jest/presets/js-with-babel";
|
||||
}
|
||||
else if (jsWithTs && !jsWithBabel) {
|
||||
presetName = "ts-jest/presets/js-with-ts";
|
||||
}
|
||||
else {
|
||||
presetName = "ts-jest/presets/default";
|
||||
}
|
||||
}
|
||||
presetName = presetName || "ts-jest/presets/default";
|
||||
preset = presets_1.allPresets[presetName];
|
||||
footNotes.push("Detected preset '" + preset.label + "' as the best matching preset for your configuration.\nVisit https://kulshekhar.github.io/ts-jest/user/config/#jest-preset for more information about presets.\n");
|
||||
}
|
||||
else if (migratedConfig.preset && migratedConfig.preset.startsWith('ts-jest')) {
|
||||
if (args.jestPreset === false) {
|
||||
delete migratedConfig.preset;
|
||||
}
|
||||
else {
|
||||
preset = presets_1.allPresets[migratedConfig.preset] || presets_1.defaults;
|
||||
}
|
||||
}
|
||||
if (preset)
|
||||
migratedConfig.preset = preset.name;
|
||||
if (migratedConfig.moduleFileExtensions && migratedConfig.moduleFileExtensions.length && preset) {
|
||||
presetValue = dedupSort(preset.value.moduleFileExtensions || []).join('::');
|
||||
migratedValue = dedupSort(migratedConfig.moduleFileExtensions).join('::');
|
||||
if (presetValue === migratedValue) {
|
||||
delete migratedConfig.moduleFileExtensions;
|
||||
}
|
||||
}
|
||||
if (migratedConfig.testRegex && preset) {
|
||||
migratedConfig.testMatch = null;
|
||||
}
|
||||
else if (migratedConfig.testMatch && migratedConfig.testMatch.length && preset) {
|
||||
presetValue = dedupSort(preset.value.testMatch || []).join('::');
|
||||
migratedValue = dedupSort(migratedConfig.testMatch).join('::');
|
||||
if (presetValue === migratedValue) {
|
||||
delete migratedConfig.testMatch;
|
||||
}
|
||||
}
|
||||
if (migratedConfig.transform) {
|
||||
Object.keys(migratedConfig.transform).forEach(function (key) {
|
||||
var val = migratedConfig.transform[key];
|
||||
if (typeof val === 'string' && /\/?ts-jest(?:\/preprocessor\.js)?$/.test(val)) {
|
||||
;
|
||||
migratedConfig.transform[key] = 'ts-jest';
|
||||
}
|
||||
});
|
||||
}
|
||||
if (preset &&
|
||||
migratedConfig.transform &&
|
||||
stableStringify(migratedConfig.transform) === stableStringify(preset.value.transform)) {
|
||||
delete migratedConfig.transform;
|
||||
}
|
||||
cleanupConfig(actualConfig);
|
||||
cleanupConfig(migratedConfig);
|
||||
before = stableStringify(actualConfig);
|
||||
after = stableStringify(migratedConfig);
|
||||
if (after === before) {
|
||||
process.stderr.write("\nNo migration needed for given Jest configuration\n ");
|
||||
return [2];
|
||||
}
|
||||
stringify = file.endsWith('.json') ? JSON.stringify : json5_1.stringify;
|
||||
prefix = file.endsWith('.json') ? '"jest": ' : 'module.exports = ';
|
||||
if (preset && migratedConfig.transform) {
|
||||
footNotes.push("\nI couldn't check if your \"transform\" value is the same as mine which is: " + stringify(preset.value.transform, undefined, ' ') + "\nIf it is the case, you can safely remove the \"transform\" from what I've migrated.\n");
|
||||
}
|
||||
process.stderr.write("\nMigrated Jest configuration:\n");
|
||||
process.stdout.write("" + prefix + stringify(migratedConfig, undefined, ' ') + "\n");
|
||||
if (footNotes.length) {
|
||||
process.stderr.write("\n" + footNotes.join('\n') + "\n");
|
||||
}
|
||||
return [2];
|
||||
});
|
||||
}); };
|
||||
function cleanupConfig(config) {
|
||||
if (config.globals) {
|
||||
if (config.globals['ts-jest'] && Object.keys(config.globals['ts-jest']).length === 0) {
|
||||
delete config.globals['ts-jest'];
|
||||
}
|
||||
if (Object.keys(config.globals).length === 0) {
|
||||
delete config.globals;
|
||||
}
|
||||
}
|
||||
if (config.transform && Object.keys(config.transform).length === 0) {
|
||||
delete config.transform;
|
||||
}
|
||||
if (config.moduleFileExtensions) {
|
||||
config.moduleFileExtensions = dedupSort(config.moduleFileExtensions);
|
||||
if (config.moduleFileExtensions.length === 0)
|
||||
delete config.moduleFileExtensions;
|
||||
}
|
||||
if (config.testMatch) {
|
||||
config.testMatch = dedupSort(config.testMatch);
|
||||
if (config.testMatch.length === 0)
|
||||
delete config.testMatch;
|
||||
}
|
||||
if (config.preset === "ts-jest/presets/default")
|
||||
config.preset = presets_1.defaults.name;
|
||||
}
|
||||
function dedupSort(arr) {
|
||||
return arr
|
||||
.filter(function (s, i, a) { return a.findIndex(function (e) { return s.toString() === e.toString(); }) === i; })
|
||||
.sort(function (a, b) { return (a.toString() > b.toString() ? 1 : a.toString() < b.toString() ? -1 : 0); });
|
||||
}
|
||||
exports.help = function () { return __awaiter(void 0, void 0, void 0, function () {
|
||||
return __generator(this, function (_a) {
|
||||
process.stdout.write("\nUsage:\n ts-jest config:migrate [options] <config-file>\n\nArguments:\n <config-file> Can be a js or json Jest config file. If it is a\n package.json file, the configuration will be read from\n the \"jest\" property.\n\nOptions:\n --js ts|babel Process .js files with ts-jest if 'ts' or with\n babel-jest if 'babel'\n --no-jest-preset Disable the use of Jest presets\n");
|
||||
return [2];
|
||||
});
|
||||
}); };
|
||||
1
node_modules/ts-jest/dist/cli/help.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/cli/help.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
46
node_modules/ts-jest/dist/cli/help.js
generated
vendored
Normal file
46
node_modules/ts-jest/dist/cli/help.js
generated
vendored
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
"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 };
|
||||
}
|
||||
};
|
||||
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");
|
||||
return [2];
|
||||
});
|
||||
}); };
|
||||
exports.help = exports.run;
|
||||
1
node_modules/ts-jest/dist/cli/helpers/presets.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/cli/helpers/presets.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
35
node_modules/ts-jest/dist/cli/helpers/presets.js
generated
vendored
Normal file
35
node_modules/ts-jest/dist/cli/helpers/presets.js
generated
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
"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() {
|
||||
return this.isDefault ? 'ts-jest' : fullName;
|
||||
},
|
||||
get label() {
|
||||
return fullName.split('/').pop();
|
||||
},
|
||||
get jsVarName() {
|
||||
return this.isDefault
|
||||
? 'defaults'
|
||||
:
|
||||
fullName
|
||||
.split('/')
|
||||
.pop()
|
||||
.replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
|
||||
},
|
||||
get value() {
|
||||
return require("../../../" + fullName.replace(/^ts-jest\//, '') + "/jest-preset");
|
||||
},
|
||||
jsImport: function (varName) {
|
||||
if (varName === void 0) { varName = 'tsjPreset'; }
|
||||
return "const { " + this.jsVarName + ": " + varName + " } = require('ts-jest/presets')";
|
||||
},
|
||||
get isDefault() {
|
||||
return fullName === "ts-jest/presets/default";
|
||||
},
|
||||
}); };
|
||||
exports.allPresets = {};
|
||||
exports.defaults = (exports.allPresets["ts-jest/presets/default"] = definePreset("ts-jest/presets/default"));
|
||||
exports.jsWithTs = (exports.allPresets["ts-jest/presets/js-with-ts"] = definePreset("ts-jest/presets/js-with-ts"));
|
||||
exports.jsWIthBabel = (exports.allPresets["ts-jest/presets/js-with-babel"] = definePreset("ts-jest/presets/js-with-babel"));
|
||||
1
node_modules/ts-jest/dist/cli/index.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/cli/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
107
node_modules/ts-jest/dist/cli/index.js
generated
vendored
Normal file
107
node_modules/ts-jest/dist/cli/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
"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 __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 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 = yargs_parser_1.default(args, {
|
||||
boolean: ['dry-run', 'jest-preset', 'allow-js', 'diff', 'babel', 'force', 'jsdom'],
|
||||
string: ['tsconfig', 'js'],
|
||||
count: ['verbose'],
|
||||
alias: { verbose: ['v'] },
|
||||
default: { jestPreset: true, verbose: 0 },
|
||||
coerce: {
|
||||
js: function (val) {
|
||||
var res = val.trim().toLowerCase();
|
||||
if (!['babel', 'ts'].includes(res))
|
||||
throw new Error("The 'js' option must be 'babel' or 'ts', given: '" + val + "'.");
|
||||
return res;
|
||||
},
|
||||
},
|
||||
});
|
||||
if (parsedArgv.allowJs != null) {
|
||||
if (parsedArgv.js)
|
||||
throw new Error("The 'allowJs' and 'js' options cannot be set together.");
|
||||
parsedArgv.js = parsedArgv.allowJs ? 'ts' : undefined;
|
||||
}
|
||||
command = parsedArgv._.shift();
|
||||
isHelp = command === 'help';
|
||||
if (isHelp)
|
||||
command = parsedArgv._.shift();
|
||||
if (!VALID_COMMANDS.includes(command))
|
||||
command = 'help';
|
||||
_a = require("./" + command.replace(/:/g, '/')), run = _a.run, help = _a.help;
|
||||
cmd = isHelp && command !== 'help' ? help : run;
|
||||
return [2, cmd(parsedArgv, logger)];
|
||||
});
|
||||
});
|
||||
}
|
||||
function processArgv() {
|
||||
return __awaiter(this, void 0, void 0, function () {
|
||||
var err_1;
|
||||
return __generator(this, function (_a) {
|
||||
switch (_a.label) {
|
||||
case 0:
|
||||
_a.trys.push([0, 2, , 3]);
|
||||
return [4, cli(process.argv.slice(2))];
|
||||
case 1:
|
||||
_a.sent();
|
||||
process.exit(0);
|
||||
return [3, 3];
|
||||
case 2:
|
||||
err_1 = _a.sent();
|
||||
logger.fatal(err_1.message);
|
||||
process.exit(1);
|
||||
return [3, 3];
|
||||
case 3: return [2];
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
exports.processArgv = processArgv;
|
||||
2
node_modules/ts-jest/dist/compiler/instance.d.ts
generated
vendored
Normal file
2
node_modules/ts-jest/dist/compiler/instance.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
export declare const SOURCE_MAPPING_PREFIX = "sourceMappingURL=";
|
||||
export declare function updateOutput(outputText: string, normalizedFileName: string, sourceMap: string): string;
|
||||
55
node_modules/ts-jest/dist/compiler/instance.js
generated
vendored
Normal file
55
node_modules/ts-jest/dist/compiler/instance.js
generated
vendored
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
"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;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createCompilerInstance = exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
|
||||
var language_service_1 = require("./language-service");
|
||||
var transpiler_1 = require("./transpiler");
|
||||
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;
|
||||
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_1.stringify(sourceMap);
|
||||
};
|
||||
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];
|
||||
return updateOutput(value, fileName, sourceMap);
|
||||
}; };
|
||||
exports.createCompilerInstance = function (configs) {
|
||||
var logger = configs.logger.child({ namespace: 'ts-compiler' });
|
||||
var compilerOptions = configs.parsedTsConfig.options;
|
||||
var extensions = ['.ts', '.tsx'];
|
||||
if (compilerOptions.allowJs) {
|
||||
extensions.push('.js');
|
||||
extensions.push('.jsx');
|
||||
}
|
||||
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 };
|
||||
};
|
||||
1
node_modules/ts-jest/dist/compiler/language-service.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/compiler/language-service.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
286
node_modules/ts-jest/dist/compiler/language-service.js
generated
vendored
Normal file
286
node_modules/ts-jest/dist/compiler/language-service.js
generated
vendored
Normal file
|
|
@ -0,0 +1,286 @@
|
|||
"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;
|
||||
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 __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("../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, 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');
|
||||
var shouldIncrementProjectVersion = false;
|
||||
var hit = isFileInCache(fileName);
|
||||
if (!hit) {
|
||||
memoryCache.files.set(fileName, {
|
||||
text: contents,
|
||||
version: 1,
|
||||
});
|
||||
shouldIncrementProjectVersion = true;
|
||||
}
|
||||
else {
|
||||
var previousContents = memoryCache.files.get(fileName).text;
|
||||
if (previousContents !== contents) {
|
||||
memoryCache.files.set(fileName, {
|
||||
text: contents,
|
||||
version: memoryCache.files.get(fileName).version + 1,
|
||||
});
|
||||
if (hit)
|
||||
shouldIncrementProjectVersion = true;
|
||||
}
|
||||
if (!fileNames.includes(fileName)) {
|
||||
shouldIncrementProjectVersion = true;
|
||||
}
|
||||
}
|
||||
if (shouldIncrementProjectVersion)
|
||||
projectVersion++;
|
||||
};
|
||||
var serviceHost = {
|
||||
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 = (_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 = isFileInCache(normalizedFileName);
|
||||
logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
|
||||
if (!hit) {
|
||||
memoryCache.files.set(normalizedFileName, {
|
||||
text: cacheReadFile(normalizedFileName),
|
||||
version: 1,
|
||||
});
|
||||
}
|
||||
var contents = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.text;
|
||||
if (contents === undefined)
|
||||
return;
|
||||
return ts.ScriptSnapshot.fromString(contents);
|
||||
},
|
||||
fileExists: memoize(ts.sys.fileExists),
|
||||
readFile: cacheReadFile,
|
||||
readDirectory: memoize(ts.sys.readDirectory),
|
||||
getDirectories: memoize(ts.sys.getDirectories),
|
||||
directoryExists: memoize(ts.sys.directoryExists),
|
||||
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.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);
|
||||
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) {
|
||||
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}}`.", {
|
||||
file: path_1.basename(fileName),
|
||||
}));
|
||||
}
|
||||
return [output.outputFiles[1].text, output.outputFiles[0].text];
|
||||
},
|
||||
program: service.getProgram(),
|
||||
};
|
||||
};
|
||||
1
node_modules/ts-jest/dist/compiler/transpiler.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/compiler/transpiler.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
24
node_modules/ts-jest/dist/compiler/transpiler.js
generated
vendored
Normal file
24
node_modules/ts-jest/dist/compiler/transpiler.js
generated
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.initializeTranspilerInstance = void 0;
|
||||
exports.initializeTranspilerInstance = function (configs, logger) {
|
||||
logger.debug('initializeTranspilerInstance(): create typescript compiler');
|
||||
var options = configs.parsedTsConfig.options;
|
||||
var ts = configs.compilerModule;
|
||||
return {
|
||||
compileFn: function (code, fileName) {
|
||||
logger.debug({ fileName: fileName }, 'compileFn(): compiling as isolated module');
|
||||
var result = ts.transpileModule(code, {
|
||||
fileName: fileName,
|
||||
transformers: configs.customTransformers,
|
||||
compilerOptions: options,
|
||||
reportDiagnostics: configs.shouldReportDiagnostics(fileName),
|
||||
});
|
||||
if (result.diagnostics && configs.shouldReportDiagnostics(fileName)) {
|
||||
configs.raiseDiagnostics(result.diagnostics, fileName, logger);
|
||||
}
|
||||
return [result.outputText, result.sourceMapText];
|
||||
},
|
||||
program: undefined,
|
||||
};
|
||||
};
|
||||
28
node_modules/ts-jest/dist/config/config-set.d.ts
generated
vendored
Normal file
28
node_modules/ts-jest/dist/config/config-set.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
import type { Config } from '@jest/types';
|
||||
import { Logger } from 'bs-logger';
|
||||
import { CompilerOptions, CustomTransformers, Diagnostic, ParsedCommandLine } from 'typescript';
|
||||
import type { TTypeScript } from '../types';
|
||||
import type { RawCompilerOptions } from '../tsconfig-raw';
|
||||
export declare class ConfigSet {
|
||||
private readonly parentLogger?;
|
||||
readonly logger: 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;
|
||||
}
|
||||
531
node_modules/ts-jest/dist/config/config-set.js
generated
vendored
Normal file
531
node_modules/ts-jest/dist/config/config-set.js
generated
vendored
Normal file
|
|
@ -0,0 +1,531 @@
|
|||
"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
|
||||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
||||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
||||
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
||||
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
||||
};
|
||||
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.");
|
||||
};
|
||||
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.ConfigSet = exports.TS_JEST_OUT_DIR = exports.IGNORE_DIAGNOSTIC_CODES = exports.MY_DIGEST = void 0;
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var fs_1 = require("fs");
|
||||
var jest_util_1 = require("jest-util");
|
||||
var json5 = require("json5");
|
||||
var path_1 = require("path");
|
||||
var typescript_1 = require("typescript");
|
||||
var instance_1 = require("../compiler/instance");
|
||||
var constants_1 = require("../constants");
|
||||
var hoist_jest_1 = require("../transformers/hoist-jest");
|
||||
var backports_1 = require("../utils/backports");
|
||||
var importer_1 = require("../utils/importer");
|
||||
var json_1 = require("../utils/json");
|
||||
var logger_1 = require("../utils/logger");
|
||||
var memoize_1 = require("../utils/memoize");
|
||||
var messages_1 = require("../utils/messages");
|
||||
var normalize_slashes_1 = require("../utils/normalize-slashes");
|
||||
var sha1_1 = require("../utils/sha1");
|
||||
var ts_error_1 = require("../utils/ts-error");
|
||||
exports.MY_DIGEST = fs_1.readFileSync(path_1.resolve(__dirname, '..', '..', '.ts-jest-digest'), 'utf8');
|
||||
exports.IGNORE_DIAGNOSTIC_CODES = [
|
||||
6059,
|
||||
18002,
|
||||
18003,
|
||||
];
|
||||
exports.TS_JEST_OUT_DIR = '$$ts-jest$$';
|
||||
var TARGET_TO_VERSION_MAPPING = (_a = {},
|
||||
_a[typescript_1.ScriptTarget.ES2018] = 'es2018',
|
||||
_a[typescript_1.ScriptTarget.ES2019] = 'es2019',
|
||||
_a[typescript_1.ScriptTarget.ES2020] = 'es2020',
|
||||
_a[typescript_1.ScriptTarget.ESNext] = 'ESNext',
|
||||
_a);
|
||||
var normalizeRegex = function (pattern) {
|
||||
return pattern ? (typeof pattern === 'string' ? pattern : pattern.source) : undefined;
|
||||
};
|
||||
var toDiagnosticCode = function (code) { var _a; return code ? (_a = parseInt(("" + code).trim().replace(/^TS/, ''), 10)) !== null && _a !== void 0 ? _a : undefined : undefined; };
|
||||
var toDiagnosticCodeList = function (items, into) {
|
||||
var e_1, _a;
|
||||
if (into === void 0) { into = []; }
|
||||
try {
|
||||
for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
|
||||
var item = items_1_1.value;
|
||||
if (typeof item === 'string') {
|
||||
var children = item.trim().split(/\s*,\s*/g);
|
||||
if (children.length > 1) {
|
||||
toDiagnosticCodeList(children, into);
|
||||
continue;
|
||||
}
|
||||
item = children[0];
|
||||
}
|
||||
if (!item)
|
||||
continue;
|
||||
var code = toDiagnosticCode(item);
|
||||
if (code && !into.includes(code))
|
||||
into.push(code);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
return into;
|
||||
};
|
||||
var ConfigSet = (function () {
|
||||
function ConfigSet(jestConfig, parentLogger) {
|
||||
var _a, _b;
|
||||
var _c, _d, _e, _f;
|
||||
this.parentLogger = parentLogger;
|
||||
this.customTransformers = Object.create(null);
|
||||
this._overriddenCompilerOptions = {
|
||||
sourceMap: true,
|
||||
inlineSourceMap: false,
|
||||
inlineSources: true,
|
||||
declaration: false,
|
||||
noEmit: false,
|
||||
removeComments: false,
|
||||
out: undefined,
|
||||
outFile: undefined,
|
||||
composite: undefined,
|
||||
declarationDir: undefined,
|
||||
declarationMap: undefined,
|
||||
emitDeclarationOnly: undefined,
|
||||
sourceRoot: undefined,
|
||||
tsBuildInfoFile: undefined,
|
||||
};
|
||||
this.logger = this.parentLogger
|
||||
? this.parentLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'config', _a))
|
||||
: logger_1.rootLogger.child({ namespace: 'config' });
|
||||
this._backportJestCfg(jestConfig !== null && jestConfig !== void 0 ? jestConfig : Object.create(null));
|
||||
this.cwd = path_1.normalize((_c = this._jestCfg.cwd) !== null && _c !== void 0 ? _c : process.cwd());
|
||||
this.rootDir = path_1.normalize((_d = this._jestCfg.rootDir) !== null && _d !== void 0 ? _d : this.cwd);
|
||||
var tsJestCfg = this._jestCfg.globals && this._jestCfg.globals['ts-jest'];
|
||||
var options = tsJestCfg !== null && tsJestCfg !== void 0 ? tsJestCfg : Object.create(null);
|
||||
this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed.", (_e = options.compiler) !== null && _e !== void 0 ? _e : 'typescript');
|
||||
this.isolatedModules = (_f = options.isolatedModules) !== null && _f !== void 0 ? _f : false;
|
||||
this.logger.debug({ compilerModule: this.compilerModule }, 'normalized compiler module config via ts-jest option');
|
||||
this._matchablePatterns = __spread(this._jestCfg.testMatch, this._jestCfg.testRegex).filter(function (pattern) {
|
||||
return pattern instanceof RegExp || typeof pattern === 'string';
|
||||
});
|
||||
if (!this._matchablePatterns.length) {
|
||||
(_b = this._matchablePatterns).push.apply(_b, __spread(constants_1.DEFAULT_JEST_TEST_MATCH));
|
||||
}
|
||||
this._matchTestFilePath = jest_util_1.globsToMatcher(this._matchablePatterns.filter(function (pattern) { return typeof pattern === 'string'; }));
|
||||
this._setupTsJestCfg(options);
|
||||
this._resolveTsCacheDir();
|
||||
}
|
||||
ConfigSet.prototype._backportJestCfg = function (jestCfg) {
|
||||
var config = backports_1.backportJestConfig(this.logger, jestCfg);
|
||||
this.logger.debug({ jestConfig: config }, 'normalized jest config');
|
||||
this._jestCfg = config;
|
||||
};
|
||||
ConfigSet.prototype._setupTsJestCfg = function (options) {
|
||||
var _this = this;
|
||||
var _a, _b, _c, _d;
|
||||
if (options.packageJson) {
|
||||
this.logger.warn("The option `packageJson` is deprecated and will be removed in ts-jest 27. This option is not used by internal `ts-jest`");
|
||||
}
|
||||
if (!options.babelConfig) {
|
||||
this.logger.debug('babel is disabled');
|
||||
}
|
||||
else {
|
||||
var baseBabelCfg = { cwd: this.cwd };
|
||||
if (typeof options.babelConfig === 'string') {
|
||||
var babelCfgPath = this.resolvePath(options.babelConfig);
|
||||
if (path_1.extname(options.babelConfig) === '.js') {
|
||||
this._babelConfig = __assign(__assign({}, baseBabelCfg), require(babelCfgPath));
|
||||
}
|
||||
else {
|
||||
this._babelConfig = __assign(__assign({}, baseBabelCfg), json5.parse(fs_1.readFileSync(babelCfgPath, 'utf-8')));
|
||||
}
|
||||
}
|
||||
else if (typeof options.babelConfig === 'object') {
|
||||
this._babelConfig = __assign(__assign({}, baseBabelCfg), options.babelConfig);
|
||||
}
|
||||
else {
|
||||
this._babelConfig = baseBabelCfg;
|
||||
}
|
||||
this.logger.debug({ babelConfig: this._babelConfig }, 'normalized babel config via ts-jest option');
|
||||
}
|
||||
if (!this._babelConfig) {
|
||||
this._overriddenCompilerOptions.module = this.compilerModule.ModuleKind.CommonJS;
|
||||
}
|
||||
else {
|
||||
this._babelJestTransformers = importer_1.importer
|
||||
.babelJest("Using \"babel-jest\" requires this package to be installed.")
|
||||
.createTransformer(this._babelConfig);
|
||||
this.logger.debug('created babel-jest transformer');
|
||||
}
|
||||
var diagnosticsOpt = (_a = options.diagnostics) !== null && _a !== void 0 ? _a : true;
|
||||
var ignoreList = __spread(exports.IGNORE_DIAGNOSTIC_CODES);
|
||||
if (typeof diagnosticsOpt === 'object') {
|
||||
var ignoreCodes = diagnosticsOpt.ignoreCodes;
|
||||
if (ignoreCodes) {
|
||||
Array.isArray(ignoreCodes) ? ignoreList.push.apply(ignoreList, __spread(ignoreCodes)) : ignoreList.push(ignoreCodes);
|
||||
}
|
||||
this._diagnostics = {
|
||||
pretty: (_b = diagnosticsOpt.pretty) !== null && _b !== void 0 ? _b : true,
|
||||
exclude: (_c = diagnosticsOpt.exclude) !== null && _c !== void 0 ? _c : [],
|
||||
ignoreCodes: toDiagnosticCodeList(ignoreList),
|
||||
throws: !diagnosticsOpt.warnOnly,
|
||||
};
|
||||
if (diagnosticsOpt.pathRegex) {
|
||||
this.logger.warn("The option `pathRegex` is deprecated and will be removed in ts-jest 27, use `exclude` instead");
|
||||
this._diagnostics = __assign(__assign({}, this._diagnostics), { pathRegex: normalizeRegex(diagnosticsOpt.pathRegex) });
|
||||
}
|
||||
}
|
||||
else {
|
||||
this._diagnostics = {
|
||||
ignoreCodes: diagnosticsOpt ? toDiagnosticCodeList(ignoreList) : [],
|
||||
exclude: [],
|
||||
pretty: true,
|
||||
throws: diagnosticsOpt,
|
||||
};
|
||||
}
|
||||
if (this._diagnostics.pathRegex && !this._diagnostics.exclude.length) {
|
||||
this._shouldGetDiagnosticsForFile = new RegExp(this._diagnostics.pathRegex);
|
||||
}
|
||||
else {
|
||||
this._shouldGetDiagnosticsForFile = this._diagnostics.exclude.length
|
||||
? jest_util_1.globsToMatcher(this._diagnostics.exclude)
|
||||
: function () { return true; };
|
||||
}
|
||||
this.logger.debug({ diagnostics: this._diagnostics }, 'normalized diagnostics config via ts-jest option');
|
||||
if (options.tsConfig) {
|
||||
this.logger.warn("The option `tsConfig` is deprecated and will be removed in ts-jest 27, use `tsconfig` instead");
|
||||
}
|
||||
var tsconfigOpt = (_d = options.tsConfig) !== null && _d !== void 0 ? _d : options.tsconfig;
|
||||
var configFilePath = typeof tsconfigOpt === 'string' ? this.resolvePath(tsconfigOpt) : undefined;
|
||||
this.parsedTsConfig = this._resolveTsConfig(typeof tsconfigOpt === 'object' ? tsconfigOpt : undefined, configFilePath);
|
||||
this.raiseDiagnostics(this.parsedTsConfig.errors, configFilePath);
|
||||
this.logger.debug({ tsconfig: this.parsedTsConfig }, 'normalized typescript config via ts-jest option');
|
||||
var astTransformers = options.astTransformers;
|
||||
this.customTransformers = {
|
||||
before: [hoist_jest_1.factory(this)],
|
||||
};
|
||||
if (astTransformers) {
|
||||
if (Array.isArray(astTransformers)) {
|
||||
this.logger.warn("The configuration for astTransformers as string[] is deprecated and will be removed in ts-jest 27. Please define your custom AST transformers in a form of an object. More information you can check online documentation https://kulshekhar.github.io/ts-jest/user/config/astTransformers");
|
||||
this.customTransformers = {
|
||||
before: __spread(this.customTransformers.before, astTransformers.map(function (transformer) {
|
||||
var transformerPath = _this.resolvePath(transformer, { nodeResolve: true });
|
||||
return require(transformerPath).factory(_this);
|
||||
})),
|
||||
};
|
||||
}
|
||||
else {
|
||||
var resolveTransformers = function (transformers) {
|
||||
return transformers.map(function (transformer) {
|
||||
var transformerPath;
|
||||
if (typeof transformer === 'string') {
|
||||
transformerPath = _this.resolvePath(transformer, { nodeResolve: true });
|
||||
return require(transformerPath).factory(_this);
|
||||
}
|
||||
else {
|
||||
transformerPath = _this.resolvePath(transformer.path, { nodeResolve: true });
|
||||
return require(transformerPath).factory(_this, transformer.options);
|
||||
}
|
||||
});
|
||||
};
|
||||
if (astTransformers.before) {
|
||||
this.customTransformers = {
|
||||
before: __spread(this.customTransformers.before, resolveTransformers(astTransformers.before)),
|
||||
};
|
||||
}
|
||||
if (astTransformers.after) {
|
||||
this.customTransformers = __assign(__assign({}, this.customTransformers), { after: resolveTransformers(astTransformers.after) });
|
||||
}
|
||||
if (astTransformers.afterDeclarations) {
|
||||
this.customTransformers = __assign(__assign({}, this.customTransformers), { afterDeclarations: resolveTransformers(astTransformers.afterDeclarations) });
|
||||
}
|
||||
}
|
||||
}
|
||||
this.logger.debug({ customTransformers: this.customTransformers }, 'normalized custom AST transformers via ts-jest option');
|
||||
if (options.stringifyContentPathRegex) {
|
||||
this._stringifyContentRegExp =
|
||||
typeof options.stringifyContentPathRegex === 'string'
|
||||
? new RegExp(normalizeRegex(options.stringifyContentPathRegex))
|
||||
: options.stringifyContentPathRegex;
|
||||
this.logger.debug({ stringifyContentPathRegex: this._stringifyContentRegExp }, 'normalized stringifyContentPathRegex config via ts-jest option');
|
||||
}
|
||||
};
|
||||
ConfigSet.prototype._resolveTsCacheDir = function () {
|
||||
if (!this._jestCfg.cache) {
|
||||
this.logger.debug('file caching disabled');
|
||||
return undefined;
|
||||
}
|
||||
var cacheSuffix = sha1_1.sha1(json_1.stringify({
|
||||
version: this.compilerModule.version,
|
||||
digest: this.tsJestDigest,
|
||||
compilerModule: this.compilerModule,
|
||||
compilerOptions: this.parsedTsConfig.options,
|
||||
isolatedModules: this.isolatedModules,
|
||||
diagnostics: this._diagnostics,
|
||||
}));
|
||||
var res = path_1.join(this._jestCfg.cacheDirectory, 'ts-jest', cacheSuffix.substr(0, 2), cacheSuffix.substr(2));
|
||||
this.logger.debug({ cacheDirectory: res }, 'will use file caching');
|
||||
this.tsCacheDir = res;
|
||||
};
|
||||
ConfigSet.prototype._resolveTsConfig = function (compilerOptions, resolvedConfigFile) {
|
||||
var e_2, _a;
|
||||
var _b;
|
||||
var config = { compilerOptions: Object.create(null) };
|
||||
var basePath = normalize_slashes_1.normalizeSlashes(this.rootDir);
|
||||
var ts = this.compilerModule;
|
||||
var configFileName = resolvedConfigFile
|
||||
? normalize_slashes_1.normalizeSlashes(resolvedConfigFile)
|
||||
: ts.findConfigFile(normalize_slashes_1.normalizeSlashes(this.rootDir), ts.sys.fileExists);
|
||||
if (configFileName) {
|
||||
this.logger.debug({ tsConfigFileName: configFileName }, 'readTsConfig(): reading', configFileName);
|
||||
var result_1 = ts.readConfigFile(configFileName, ts.sys.readFile);
|
||||
if (result_1.error) {
|
||||
return { errors: [result_1.error], fileNames: [], options: {} };
|
||||
}
|
||||
config = result_1.config;
|
||||
basePath = normalize_slashes_1.normalizeSlashes(path_1.dirname(configFileName));
|
||||
}
|
||||
config.compilerOptions = __assign(__assign({}, config.compilerOptions), compilerOptions);
|
||||
var result = ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName);
|
||||
if (result.options.sourceMap === false) {
|
||||
this.logger.warn(messages_1.interpolate("Got `sourceMap: false` from tsconfig file \"{{path}}\". This will disable source map support in ts-jest 27. Please set `sourceMap: true` in your tsconfig file \"{{path}}\" if you want to keep source map support on", {
|
||||
path: result.options.configFilePath,
|
||||
}));
|
||||
}
|
||||
var forcedOptions = this._overriddenCompilerOptions;
|
||||
var finalOptions = result.options;
|
||||
if (finalOptions.target === undefined) {
|
||||
finalOptions.target = ts.ScriptTarget.ES5;
|
||||
}
|
||||
var target = finalOptions.target;
|
||||
var defaultModule = [ts.ScriptTarget.ES3, ts.ScriptTarget.ES5].includes(target)
|
||||
? ts.ModuleKind.CommonJS
|
||||
: ts.ModuleKind.ESNext;
|
||||
var moduleValue = finalOptions.module == null ? defaultModule : finalOptions.module;
|
||||
if ('module' in forcedOptions &&
|
||||
moduleValue !== forcedOptions.module &&
|
||||
!(finalOptions.esModuleInterop || finalOptions.allowSyntheticDefaultImports)) {
|
||||
result.errors.push({
|
||||
code: 151001,
|
||||
messageText: "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.",
|
||||
category: ts.DiagnosticCategory.Message,
|
||||
file: undefined,
|
||||
start: undefined,
|
||||
length: undefined,
|
||||
});
|
||||
if (!('allowSyntheticDefaultImports' in config.compilerOptions)) {
|
||||
finalOptions.allowSyntheticDefaultImports = true;
|
||||
}
|
||||
}
|
||||
if (finalOptions.allowJs && !finalOptions.outDir) {
|
||||
finalOptions.outDir = exports.TS_JEST_OUT_DIR;
|
||||
}
|
||||
try {
|
||||
for (var _c = __values(Object.keys(forcedOptions)), _d = _c.next(); !_d.done; _d = _c.next()) {
|
||||
var key = _d.value;
|
||||
var val = forcedOptions[key];
|
||||
if (val === undefined) {
|
||||
delete finalOptions[key];
|
||||
}
|
||||
else {
|
||||
finalOptions[key] = val;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
var nodeJsVer = process.version;
|
||||
var compilationTarget = result.options.target;
|
||||
if (!this._babelConfig &&
|
||||
((nodeJsVer.startsWith('v10') && compilationTarget > typescript_1.ScriptTarget.ES2018) ||
|
||||
(nodeJsVer.startsWith('v12') && compilationTarget > typescript_1.ScriptTarget.ES2019))) {
|
||||
var message = messages_1.interpolate("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping", {
|
||||
nodeJsVer: process.version,
|
||||
compilationTarget: (_b = config.compilerOptions.target) !== null && _b !== void 0 ? _b : TARGET_TO_VERSION_MAPPING[compilationTarget],
|
||||
});
|
||||
this.logger.warn(message);
|
||||
}
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(ConfigSet.prototype, "tsCompiler", {
|
||||
get: function () {
|
||||
return instance_1.createCompilerInstance(this);
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "babelConfig", {
|
||||
get: function () {
|
||||
return this._babelConfig;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "babelJestTransformer", {
|
||||
get: function () {
|
||||
return this._babelJestTransformers;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsJestDigest", {
|
||||
get: function () {
|
||||
return exports.MY_DIGEST;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "hooks", {
|
||||
get: function () {
|
||||
var hooksFile = process.env.TS_JEST_HOOKS;
|
||||
if (hooksFile) {
|
||||
hooksFile = path_1.resolve(this.cwd, hooksFile);
|
||||
return importer_1.importer.tryTheseOr(hooksFile, {});
|
||||
}
|
||||
return {};
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
ConfigSet.prototype.isTestFile = function (fileName) {
|
||||
var _this = this;
|
||||
return this._matchablePatterns.some(function (pattern) {
|
||||
return typeof pattern === 'string' ? _this._matchTestFilePath(fileName) : pattern.test(fileName);
|
||||
});
|
||||
};
|
||||
ConfigSet.prototype.shouldStringifyContent = function (filePath) {
|
||||
return this._stringifyContentRegExp ? this._stringifyContentRegExp.test(filePath) : false;
|
||||
};
|
||||
ConfigSet.prototype.raiseDiagnostics = function (diagnostics, filePath, logger) {
|
||||
var _this = this;
|
||||
var ignoreCodes = this._diagnostics.ignoreCodes;
|
||||
var DiagnosticCategory = this.compilerModule.DiagnosticCategory;
|
||||
var filteredDiagnostics = filePath && !this.shouldReportDiagnostics(filePath)
|
||||
? []
|
||||
: diagnostics.filter(function (diagnostic) {
|
||||
var _a;
|
||||
if (((_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.fileName) && !_this.shouldReportDiagnostics(diagnostic.file.fileName)) {
|
||||
return false;
|
||||
}
|
||||
return !ignoreCodes.includes(diagnostic.code);
|
||||
});
|
||||
if (!filteredDiagnostics.length)
|
||||
return;
|
||||
var error = this._createTsError(filteredDiagnostics);
|
||||
var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
|
||||
if (this._diagnostics.throws && filteredDiagnostics.some(function (d) { return importantCategories.includes(d.category); })) {
|
||||
throw error;
|
||||
}
|
||||
logger ? logger.warn({ error: error }, error.message) : this.logger.warn({ error: error }, error.message);
|
||||
};
|
||||
ConfigSet.prototype.shouldReportDiagnostics = function (filePath) {
|
||||
return this._shouldGetDiagnosticsForFile instanceof RegExp
|
||||
? this._shouldGetDiagnosticsForFile.test(filePath)
|
||||
: this._shouldGetDiagnosticsForFile(filePath);
|
||||
};
|
||||
ConfigSet.prototype._createTsError = function (diagnostics) {
|
||||
var _this = this;
|
||||
var formatDiagnostics = this._diagnostics.pretty
|
||||
? this.compilerModule.formatDiagnosticsWithColorAndContext
|
||||
: this.compilerModule.formatDiagnostics;
|
||||
var diagnosticHost = {
|
||||
getNewLine: function () { return '\n'; },
|
||||
getCurrentDirectory: function () { return _this.cwd; },
|
||||
getCanonicalFileName: function (path) { return path; },
|
||||
};
|
||||
var diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
|
||||
var diagnosticCodes = diagnostics.map(function (x) { return x.code; });
|
||||
return new ts_error_1.TSError(diagnosticText, diagnosticCodes);
|
||||
};
|
||||
ConfigSet.prototype.resolvePath = function (inputPath, _a) {
|
||||
var _b = _a === void 0 ? {} : _a, _c = _b.throwIfMissing, throwIfMissing = _c === void 0 ? true : _c, _d = _b.nodeResolve, nodeResolve = _d === void 0 ? false : _d;
|
||||
var path = inputPath;
|
||||
var nodeResolved = false;
|
||||
if (path.startsWith('<rootDir>')) {
|
||||
path = path_1.resolve(path_1.join(this.rootDir, path.substr(9)));
|
||||
}
|
||||
else if (!path_1.isAbsolute(path)) {
|
||||
if (!path.startsWith('.') && nodeResolve) {
|
||||
try {
|
||||
path = require.resolve(path);
|
||||
nodeResolved = true;
|
||||
}
|
||||
catch (_) { }
|
||||
}
|
||||
if (!nodeResolved) {
|
||||
path = path_1.resolve(this.cwd, path);
|
||||
}
|
||||
}
|
||||
if (!nodeResolved && nodeResolve) {
|
||||
try {
|
||||
path = require.resolve(path);
|
||||
nodeResolved = true;
|
||||
}
|
||||
catch (_) { }
|
||||
}
|
||||
if (throwIfMissing && !fs_1.existsSync(path)) {
|
||||
throw new Error(messages_1.interpolate("File not found: {{inputPath}} (resolved as: {{resolvedPath}})", { inputPath: inputPath, resolvedPath: path }));
|
||||
}
|
||||
this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
|
||||
return path;
|
||||
};
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsCompiler", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsJestDigest", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "hooks", null);
|
||||
return ConfigSet;
|
||||
}());
|
||||
exports.ConfigSet = ConfigSet;
|
||||
6
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts
generated
vendored
Normal file
6
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +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;
|
||||
}) => JestPathMapping;
|
||||
export {};
|
||||
64
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js
generated
vendored
Normal file
64
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js
generated
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
"use strict";
|
||||
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.");
|
||||
};
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.pathsToModuleNameMapper = void 0;
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
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 ? 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()) {
|
||||
var fromPath = _e.value;
|
||||
var pattern = void 0;
|
||||
var toPaths = mapping[fromPath];
|
||||
if (toPaths.length === 0) {
|
||||
logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target.", { path: fromPath }));
|
||||
continue;
|
||||
}
|
||||
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] = 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] = paths.length === 1 ? paths[0] : paths;
|
||||
}
|
||||
else {
|
||||
logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`).", { path: fromPath }));
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
return jestMap;
|
||||
};
|
||||
4
node_modules/ts-jest/dist/constants.d.ts
generated
vendored
Normal file
4
node_modules/ts-jest/dist/constants.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
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";
|
||||
8
node_modules/ts-jest/dist/constants.js
generated
vendored
Normal file
8
node_modules/ts-jest/dist/constants.js
generated
vendored
Normal file
|
|
@ -0,0 +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.TS_TSX_REGEX = /\.tsx?$/;
|
||||
exports.JS_JSX_REGEX = /\.jsx?$/;
|
||||
exports.DECLARATION_TYPE_EXT = '.d.ts';
|
||||
exports.DEFAULT_JEST_TEST_MATCH = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'];
|
||||
19
node_modules/ts-jest/dist/index.d.ts
generated
vendored
Normal file
19
node_modules/ts-jest/dist/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
import { createJestPreset as createJestPresetCore } from './presets/create-jest-preset';
|
||||
import { TsJestTransformer } from './ts-jest-transformer';
|
||||
import type { TsJestGlobalOptions } from './types';
|
||||
import { mocked as mockedCore } from './utils/testing';
|
||||
declare module '@jest/types' {
|
||||
namespace Config {
|
||||
interface ConfigGlobals {
|
||||
'ts-jest': TsJestGlobalOptions;
|
||||
}
|
||||
}
|
||||
}
|
||||
export declare const mocked: typeof mockedCore;
|
||||
export declare const createJestPreset: typeof createJestPresetCore;
|
||||
export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
|
||||
prefix: string;
|
||||
}) => {
|
||||
[key: string]: string | string[];
|
||||
} | undefined;
|
||||
export declare function createTransformer(): TsJestTransformer;
|
||||
24
node_modules/ts-jest/dist/index.js
generated
vendored
Normal file
24
node_modules/ts-jest/dist/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
"use strict";
|
||||
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 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("./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);
|
||||
};
|
||||
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);
|
||||
function createTransformer() {
|
||||
version_checkers_1.VersionCheckers.jest.warn();
|
||||
return new ts_jest_transformer_1.TsJestTransformer();
|
||||
}
|
||||
exports.createTransformer = createTransformer;
|
||||
7
node_modules/ts-jest/dist/presets/create-jest-preset.d.ts
generated
vendored
Normal file
7
node_modules/ts-jest/dist/presets/create-jest-preset.d.ts
generated
vendored
Normal 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 {};
|
||||
24
node_modules/ts-jest/dist/presets/create-jest-preset.js
generated
vendored
Normal file
24
node_modules/ts-jest/dist/presets/create-jest-preset.js
generated
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
"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);
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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;
|
||||
var _c = (_a === void 0 ? {} : _a).allowJs, allowJs = _c === void 0 ? false : _c;
|
||||
if (from === void 0) { from = {}; }
|
||||
logger.debug({ allowJs: allowJs }, 'creating jest presets', allowJs ? 'handling' : 'not handling', 'JavaScript files');
|
||||
return __assign(__assign({ transform: __assign(__assign({}, from.transform), (_b = {}, _b[allowJs ? '^.+\\.[tj]sx?$' : '^.+\\.tsx?$'] = 'ts-jest', _b)) }, (from.testMatch ? { testMatch: from.testMatch } : undefined)), (from.moduleFileExtensions ? { moduleFileExtensions: from.moduleFileExtensions } : undefined));
|
||||
}
|
||||
exports.createJestPreset = createJestPreset;
|
||||
1
node_modules/ts-jest/dist/transformers/hoist-jest.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/transformers/hoist-jest.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
131
node_modules/ts-jest/dist/transformers/hoist-jest.js
generated
vendored
Normal file
131
node_modules/ts-jest/dist/transformers/hoist-jest.js
generated
vendored
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
"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;
|
||||
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;
|
||||
};
|
||||
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 = 4;
|
||||
function factory(cs) {
|
||||
var logger = cs.logger.child({ namespace: 'ts-hoisting' });
|
||||
var ts = cs.compilerModule;
|
||||
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 = [];
|
||||
var enter = function () {
|
||||
level++;
|
||||
if (hoisted[level]) {
|
||||
hoisted[level].splice(0, hoisted[level].length);
|
||||
}
|
||||
};
|
||||
var exit = function () { return level--; };
|
||||
var hoist = function (node) {
|
||||
if (hoisted[level]) {
|
||||
hoisted[level].push(node);
|
||||
}
|
||||
else {
|
||||
hoisted[level] = [node];
|
||||
}
|
||||
};
|
||||
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) && !isJestGlobalImport(s); });
|
||||
var newNode = ts.getMutableClone(resultNode);
|
||||
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)) {
|
||||
hoist(resultNode);
|
||||
}
|
||||
return resultNode;
|
||||
};
|
||||
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(): hoisting', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });
|
||||
};
|
||||
}
|
||||
exports.factory = factory;
|
||||
1
node_modules/ts-jest/dist/transformers/index.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/transformers/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
24
node_modules/ts-jest/dist/transformers/index.js
generated
vendored
Normal file
24
node_modules/ts-jest/dist/transformers/index.js
generated
vendored
Normal file
|
|
@ -0,0 +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 });
|
||||
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
3
node_modules/ts-jest/dist/transformers/path-mapping.d.ts
generated
vendored
Normal 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
121
node_modules/ts-jest/dist/transformers/path-mapping.js
generated
vendored
Normal 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;
|
||||
12
node_modules/ts-jest/dist/ts-jest-transformer.d.ts
generated
vendored
Normal file
12
node_modules/ts-jest/dist/ts-jest-transformer.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
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';
|
||||
export declare class TsJestTransformer implements Transformer {
|
||||
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;
|
||||
}
|
||||
114
node_modules/ts-jest/dist/ts-jest-transformer.js
generated
vendored
Normal file
114
node_modules/ts-jest/dist/ts-jest-transformer.js
generated
vendored
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
"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);
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.TsJestTransformer = void 0;
|
||||
var config_set_1 = require("./config/config-set");
|
||||
var constants_1 = require("./constants");
|
||||
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() {
|
||||
this.logger = logger_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
|
||||
this.logger.debug('created new transformer');
|
||||
}
|
||||
TsJestTransformer.prototype.configsFor = function (jestConfig) {
|
||||
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,
|
||||
});
|
||||
}
|
||||
}
|
||||
return configSet;
|
||||
};
|
||||
TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
|
||||
this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'processing', filePath);
|
||||
var result;
|
||||
var source = input;
|
||||
var configs = this.configsFor(jestConfig);
|
||||
var hooks = configs.hooks;
|
||||
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 (shouldStringifyContent) {
|
||||
result = "module.exports=" + json_1.stringify(source);
|
||||
}
|
||||
else if (isDefinitionFile) {
|
||||
result = '';
|
||||
}
|
||||
else if (!configs.parsedTsConfig.options.allowJs && isJsFile) {
|
||||
this.logger.warn({ fileName: filePath }, messages_1.interpolate("Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore", { path: filePath }));
|
||||
result = source;
|
||||
}
|
||||
else if (isJsFile || isTsFile) {
|
||||
result = configs.tsCompiler.compile(source, filePath);
|
||||
}
|
||||
else {
|
||||
var message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
|
||||
this.logger.warn({ fileName: filePath }, messages_1.interpolate(message, { path: filePath }));
|
||||
result = source;
|
||||
}
|
||||
if (babelJest) {
|
||||
this.logger.debug({ fileName: filePath }, 'calling babel-jest processor');
|
||||
result = babelJest.process(result, filePath, jestConfig, __assign(__assign({}, transformOptions), { instrument: false }));
|
||||
}
|
||||
if (hooks.afterProcess) {
|
||||
this.logger.debug({ fileName: filePath, hookName: 'afterProcess' }, 'calling afterProcess hook');
|
||||
var newResult = hooks.afterProcess([input, filePath, jestConfig, transformOptions], result);
|
||||
if (newResult !== undefined) {
|
||||
return newResult;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, _jestConfigStr, transformOptions) {
|
||||
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(this._transformCfgStr, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
|
||||
};
|
||||
TsJestTransformer._cachedConfigSets = [];
|
||||
return TsJestTransformer;
|
||||
}());
|
||||
exports.TsJestTransformer = TsJestTransformer;
|
||||
105
node_modules/ts-jest/dist/tsconfig-raw.d.ts
generated
vendored
Normal file
105
node_modules/ts-jest/dist/tsconfig-raw.d.ts
generated
vendored
Normal 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
2
node_modules/ts-jest/dist/tsconfig-raw.js
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
50
node_modules/ts-jest/dist/types.d.ts
generated
vendored
Normal file
50
node_modules/ts-jest/dist/types.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
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 | RawCompilerOptions;
|
||||
tsconfig?: boolean | string | RawCompilerOptions;
|
||||
packageJson?: boolean | string | Record<string, unknown>;
|
||||
isolatedModules?: boolean;
|
||||
compiler?: 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;
|
||||
}
|
||||
export interface GlobalConfigTsJest extends Config.ConfigGlobals {
|
||||
'ts-jest': TsJestGlobalOptions;
|
||||
}
|
||||
export interface InitialOptionsTsJest extends Config.InitialOptions {
|
||||
globals?: GlobalConfigTsJest;
|
||||
}
|
||||
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;
|
||||
}
|
||||
export interface TsCompiler {
|
||||
program: _ts.Program | undefined;
|
||||
}
|
||||
2
node_modules/ts-jest/dist/types.js
generated
vendored
Normal file
2
node_modules/ts-jest/dist/types.js
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
1
node_modules/ts-jest/dist/utils/backports.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/backports.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
104
node_modules/ts-jest/dist/utils/backports.js
generated
vendored
Normal file
104
node_modules/ts-jest/dist/utils/backports.js
generated
vendored
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
"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 _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 _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) {
|
||||
hadWarnings = true;
|
||||
logger.warn(context, messages_1.interpolate(note ? "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n \u21B3 {{note}}" : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.", {
|
||||
oldPath: oldPath,
|
||||
newPath: newPath,
|
||||
note: note,
|
||||
}));
|
||||
};
|
||||
if ('__TS_CONFIG__' in globals) {
|
||||
warnConfig('globals.__TS_CONFIG__', 'globals.ts-jest.tsConfig');
|
||||
if (typeof globals.__TS_CONFIG__ === 'object') {
|
||||
mergeTsJest.tsConfig = globals.__TS_CONFIG__;
|
||||
}
|
||||
delete globals.__TS_CONFIG__;
|
||||
}
|
||||
if ('__TRANSFORM_HTML__' in globals) {
|
||||
warnConfig('globals.__TRANSFORM_HTML__', 'globals.ts-jest.stringifyContentPathRegex');
|
||||
if (globals.__TRANSFORM_HTML__) {
|
||||
mergeTsJest.stringifyContentPathRegex = '\\.html?$';
|
||||
}
|
||||
delete globals.__TRANSFORM_HTML__;
|
||||
}
|
||||
if ('typeCheck' in tsJest) {
|
||||
warnConfig('globals.ts-jest.typeCheck', 'globals.ts-jest.isolatedModules');
|
||||
mergeTsJest.isolatedModules = !tsJest.typeCheck;
|
||||
delete tsJest.typeCheck;
|
||||
}
|
||||
if ('tsConfigFile' in tsJest) {
|
||||
warnConfig('globals.ts-jest.tsConfigFile', 'globals.ts-jest.tsConfig');
|
||||
if (tsJest.tsConfigFile) {
|
||||
mergeTsJest.tsConfig = tsJest.tsConfigFile;
|
||||
}
|
||||
delete tsJest.tsConfigFile;
|
||||
}
|
||||
if ('enableTsDiagnostics' in tsJest) {
|
||||
warnConfig('globals.ts-jest.enableTsDiagnostics', 'globals.ts-jest.diagnostics');
|
||||
if (tsJest.enableTsDiagnostics) {
|
||||
mergeTsJest.diagnostics = { warnOnly: true };
|
||||
if (typeof tsJest.enableTsDiagnostics === 'string')
|
||||
mergeTsJest.diagnostics.pathRegex = tsJest.enableTsDiagnostics;
|
||||
}
|
||||
else {
|
||||
mergeTsJest.diagnostics = false;
|
||||
}
|
||||
delete tsJest.enableTsDiagnostics;
|
||||
}
|
||||
if ('useBabelrc' in tsJest) {
|
||||
warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845");
|
||||
if (tsJest.useBabelrc != null) {
|
||||
mergeTsJest.babelConfig = tsJest.useBabelrc ? true : {};
|
||||
}
|
||||
delete tsJest.useBabelrc;
|
||||
}
|
||||
if ('skipBabel' in tsJest) {
|
||||
warnConfig('globals.ts-jest.skipBabel', 'globals.ts-jest.babelConfig');
|
||||
if (tsJest.skipBabel === false && !mergeTsJest.babelConfig) {
|
||||
mergeTsJest.babelConfig = true;
|
||||
}
|
||||
delete tsJest.skipBabel;
|
||||
}
|
||||
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), { 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) {
|
||||
var shouldLog = !/^\s*(?:0|f(?:alse)?|no?|disabled?|off|)\s*$/i.test(process.env.TS_JEST_DEBUG || '');
|
||||
delete process.env.TS_JEST_DEBUG;
|
||||
if (shouldLog) {
|
||||
process.env.TS_JEST_LOG = 'ts-jest.log,stderr:warn';
|
||||
}
|
||||
logger.warn(context, messages_1.interpolate("Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead.", {
|
||||
old: 'TS_JEST_DEBUG',
|
||||
new: 'TS_JEST_LOG',
|
||||
}));
|
||||
}
|
||||
};
|
||||
1
node_modules/ts-jest/dist/utils/get-package-version.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/get-package-version.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
11
node_modules/ts-jest/dist/utils/get-package-version.js
generated
vendored
Normal file
11
node_modules/ts-jest/dist/utils/get-package-version.js
generated
vendored
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getPackageVersion = void 0;
|
||||
function getPackageVersion(moduleName) {
|
||||
try {
|
||||
return require(moduleName + "/package.json").version;
|
||||
}
|
||||
catch (err) { }
|
||||
return;
|
||||
}
|
||||
exports.getPackageVersion = getPackageVersion;
|
||||
1
node_modules/ts-jest/dist/utils/importer.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/importer.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
197
node_modules/ts-jest/dist/utils/importer.js
generated
vendored
Normal file
197
node_modules/ts-jest/dist/utils/importer.js
generated
vendored
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
|
||||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
||||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
||||
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
||||
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
||||
};
|
||||
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;
|
||||
};
|
||||
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");
|
||||
var version_checkers_1 = require("./version-checkers");
|
||||
var logger = logger_1.rootLogger.child({ namespace: 'Importer' });
|
||||
var passThru = function (action) { return function (input) {
|
||||
action();
|
||||
return input;
|
||||
}; };
|
||||
var Importer = (function () {
|
||||
function Importer(_patches) {
|
||||
if (_patches === void 0) { _patches = {}; }
|
||||
this._patches = _patches;
|
||||
}
|
||||
Object.defineProperty(Importer, "instance", {
|
||||
get: function () {
|
||||
logger.debug('creating Importer singleton');
|
||||
return new Importer({
|
||||
'@babel/core': [passThru(version_checkers_1.VersionCheckers.babelCore.warn)],
|
||||
'babel-jest': [passThru(version_checkers_1.VersionCheckers.babelJest.warn)],
|
||||
typescript: [passThru(version_checkers_1.VersionCheckers.typescript.warn)],
|
||||
jest: [passThru(version_checkers_1.VersionCheckers.jest.warn)],
|
||||
});
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Importer.prototype.babelJest = function (why) {
|
||||
return this._import(why, 'babel-jest');
|
||||
};
|
||||
Importer.prototype.babelCore = function (why) {
|
||||
return this._import(why, '@babel/core');
|
||||
};
|
||||
Importer.prototype.typescript = function (why, which) {
|
||||
return this._import(why, which);
|
||||
};
|
||||
Importer.prototype.tryThese = function (moduleName) {
|
||||
var fallbacks = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
fallbacks[_i - 1] = arguments[_i];
|
||||
}
|
||||
var name;
|
||||
var loaded;
|
||||
var tries = __spread([moduleName], fallbacks);
|
||||
while ((name = tries.shift()) !== undefined) {
|
||||
var req = requireWrapper(name);
|
||||
var contextReq = __assign({}, req);
|
||||
delete contextReq.exports;
|
||||
if (req.exists) {
|
||||
loaded = req;
|
||||
if (loaded.error) {
|
||||
logger.error({ requireResult: contextReq }, "failed loading module '" + name + "'", loaded.error.message);
|
||||
}
|
||||
else {
|
||||
logger.debug({ requireResult: contextReq }, 'loaded module', name);
|
||||
loaded.exports = this._patch(name, loaded.exports);
|
||||
}
|
||||
break;
|
||||
}
|
||||
else {
|
||||
logger.debug({ requireResult: contextReq }, "module '" + name + "' not found");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return loaded;
|
||||
};
|
||||
Importer.prototype.tryTheseOr = function (moduleNames, missingResult, allowLoadError) {
|
||||
if (allowLoadError === void 0) { allowLoadError = false; }
|
||||
var args = Array.isArray(moduleNames) ? moduleNames : [moduleNames];
|
||||
var result = this.tryThese.apply(this, __spread(args));
|
||||
if (!result)
|
||||
return missingResult;
|
||||
if (!result.error)
|
||||
return result.exports;
|
||||
if (allowLoadError)
|
||||
return missingResult;
|
||||
throw result.error;
|
||||
};
|
||||
Importer.prototype._patch = function (name, unpatched) {
|
||||
if (name in this._patches) {
|
||||
logger.debug('patching', name);
|
||||
return this._patches[name].reduce(function (mod, patcher) { return patcher(mod); }, unpatched);
|
||||
}
|
||||
return unpatched;
|
||||
};
|
||||
Importer.prototype._import = function (why, moduleName, _a) {
|
||||
var _b = _a === void 0 ? {} : _a, _c = _b.alternatives, alternatives = _c === void 0 ? [] : _c, _d = _b.installTip, installTip = _d === void 0 ? moduleName : _d;
|
||||
var res = this.tryThese.apply(this, __spread([moduleName], alternatives));
|
||||
if (res && res.exists) {
|
||||
if (!res.error)
|
||||
return res.exports;
|
||||
throw new Error(messages_1.interpolate("Loading module {{module}} failed with error: {{error}}", { module: res.given, error: res.error.message }));
|
||||
}
|
||||
var msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
|
||||
var loadModule = __spread([moduleName], alternatives).map(function (m) { return "\"" + m + "\""; }).join(', ');
|
||||
if (typeof installTip === 'string') {
|
||||
installTip = [{ module: installTip, label: "install \"" + installTip + "\"" }];
|
||||
}
|
||||
var fix = installTip
|
||||
.map(function (tip) { return " " + (installTip.length === 1 ? '↳' : '•') + " " + messages_1.interpolate("{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)", tip); })
|
||||
.join('\n');
|
||||
throw new Error(messages_1.interpolate(msg, {
|
||||
module: loadModule,
|
||||
reason: why,
|
||||
fix: fix,
|
||||
}));
|
||||
};
|
||||
__decorate([
|
||||
memoize_1.Memoize(function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
return args.join(':');
|
||||
})
|
||||
], Importer.prototype, "tryThese", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize(function (name) { return name; })
|
||||
], Importer.prototype, "_patch", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], Importer, "instance", null);
|
||||
return Importer;
|
||||
}());
|
||||
exports.Importer = Importer;
|
||||
exports.importer = Importer.instance;
|
||||
function requireWrapper(moduleName) {
|
||||
var path;
|
||||
var exists = false;
|
||||
try {
|
||||
path = resolveModule(moduleName);
|
||||
exists = true;
|
||||
}
|
||||
catch (error) {
|
||||
return { error: error, exists: exists, given: moduleName };
|
||||
}
|
||||
var result = { exists: exists, path: path, given: moduleName };
|
||||
try {
|
||||
result.exports = requireModule(path);
|
||||
}
|
||||
catch (error) {
|
||||
try {
|
||||
result.exports = requireModule(moduleName);
|
||||
}
|
||||
catch (error) {
|
||||
result.error = error;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
var requireModule = function (mod) { return require(mod); };
|
||||
var resolveModule = function (mod) { return require.resolve(mod, { paths: [process.cwd(), __dirname] }); };
|
||||
function __requireModule(localRequire, localResolve) {
|
||||
requireModule = localRequire;
|
||||
resolveModule = localResolve;
|
||||
}
|
||||
exports.__requireModule = __requireModule;
|
||||
2
node_modules/ts-jest/dist/utils/json.d.ts
generated
vendored
Normal file
2
node_modules/ts-jest/dist/utils/json.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
export declare function stringify(input: unknown): string;
|
||||
export declare function parse(input: string): any;
|
||||
32
node_modules/ts-jest/dist/utils/json.js
generated
vendored
Normal file
32
node_modules/ts-jest/dist/utils/json.js
generated
vendored
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
"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) {
|
||||
return input === undefined ? UNDEFINED : stableStringify(input);
|
||||
}
|
||||
exports.stringify = stringify;
|
||||
function parse(input) {
|
||||
return input === UNDEFINED ? undefined : JSON.parse(input);
|
||||
}
|
||||
exports.parse = parse;
|
||||
function normalize(input, _a) {
|
||||
var _b = (_a === void 0 ? {} : _a).parse, parser = _b === void 0 ? parse : _b;
|
||||
var result;
|
||||
if (normalize.cache.has(input)) {
|
||||
result = normalize.cache.get(input);
|
||||
}
|
||||
else {
|
||||
var data = parser(input);
|
||||
result = stringify(data);
|
||||
if (result === input)
|
||||
result = undefined;
|
||||
normalize.cache.set(input, result);
|
||||
}
|
||||
return result === undefined ? input : result;
|
||||
}
|
||||
exports.normalize = normalize;
|
||||
(function (normalize) {
|
||||
normalize.cache = new Map();
|
||||
})(normalize = exports.normalize || (exports.normalize = {}));
|
||||
10
node_modules/ts-jest/dist/utils/jsonable-value.d.ts
generated
vendored
Normal file
10
node_modules/ts-jest/dist/utils/jsonable-value.d.ts
generated
vendored
Normal 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;
|
||||
}
|
||||
35
node_modules/ts-jest/dist/utils/jsonable-value.js
generated
vendored
Normal file
35
node_modules/ts-jest/dist/utils/jsonable-value.js
generated
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.JsonableValue = void 0;
|
||||
var json_1 = require("./json");
|
||||
var JsonableValue = (function () {
|
||||
function JsonableValue(value) {
|
||||
this.value = value;
|
||||
}
|
||||
Object.defineProperty(JsonableValue.prototype, "value", {
|
||||
get: function () {
|
||||
return this._value;
|
||||
},
|
||||
set: function (value) {
|
||||
this._value = value;
|
||||
this._serialized = json_1.stringify(value);
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(JsonableValue.prototype, "serialized", {
|
||||
get: function () {
|
||||
return this._serialized;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
JsonableValue.prototype.valueOf = function () {
|
||||
return this._value;
|
||||
};
|
||||
JsonableValue.prototype.toString = function () {
|
||||
return this._serialized;
|
||||
};
|
||||
return JsonableValue;
|
||||
}());
|
||||
exports.JsonableValue = JsonableValue;
|
||||
1
node_modules/ts-jest/dist/utils/logger.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/logger.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export declare let rootLogger: import("bs-logger/dist/logger").Logger;
|
||||
22
node_modules/ts-jest/dist/utils/logger.js
generated
vendored
Normal file
22
node_modules/ts-jest/dist/utils/logger.js
generated
vendored
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
"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;
|
||||
var buildOptions = function () {
|
||||
var _a;
|
||||
return ({
|
||||
context: (_a = {},
|
||||
_a[bs_logger_1.LogContexts.package] = 'ts-jest',
|
||||
_a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
|
||||
_a.version = require('../../package.json').version,
|
||||
_a),
|
||||
targets: process.env.TS_JEST_LOG || undefined,
|
||||
});
|
||||
};
|
||||
exports.rootLogger = bs_logger_1.createLogger(buildOptions());
|
||||
backports_1.backportTsJestDebugEnvVar(exports.rootLogger);
|
||||
if (original !== process.env.TS_JEST_LOG) {
|
||||
exports.rootLogger = bs_logger_1.createLogger(buildOptions());
|
||||
}
|
||||
1
node_modules/ts-jest/dist/utils/memoize.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/memoize.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
48
node_modules/ts-jest/dist/utils/memoize.js
generated
vendored
Normal file
48
node_modules/ts-jest/dist/utils/memoize.js
generated
vendored
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Memoize = void 0;
|
||||
var cacheProp = Symbol.for('[memoize]');
|
||||
function Memoize(keyBuilder) {
|
||||
return function (_, propertyKey, descriptor) {
|
||||
if (descriptor.value != null) {
|
||||
descriptor.value = memoize(propertyKey, descriptor.value, keyBuilder || (function (v) { return v; }));
|
||||
}
|
||||
else if (descriptor.get != null) {
|
||||
descriptor.get = memoize(propertyKey, descriptor.get, keyBuilder || (function () { return propertyKey; }));
|
||||
}
|
||||
};
|
||||
}
|
||||
exports.Memoize = Memoize;
|
||||
function ensureCache(target, reset) {
|
||||
if (reset === void 0) { reset = false; }
|
||||
if (reset || !target[cacheProp]) {
|
||||
Object.defineProperty(target, cacheProp, {
|
||||
value: Object.create(null),
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
return target[cacheProp];
|
||||
}
|
||||
function ensureChildCache(target, key, reset) {
|
||||
if (reset === void 0) { reset = false; }
|
||||
var dict = ensureCache(target);
|
||||
if (reset || !dict[key]) {
|
||||
dict[key] = new Map();
|
||||
}
|
||||
return dict[key];
|
||||
}
|
||||
function memoize(namespace, func, keyBuilder) {
|
||||
return function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
var cache = ensureChildCache(this, namespace);
|
||||
var key = keyBuilder.apply(this, args);
|
||||
if (cache.has(key))
|
||||
return cache.get(key);
|
||||
var res = func.apply(this, args);
|
||||
cache.set(key, res);
|
||||
return res;
|
||||
};
|
||||
}
|
||||
1
node_modules/ts-jest/dist/utils/messages.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/messages.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
8
node_modules/ts-jest/dist/utils/messages.js
generated
vendored
Normal file
8
node_modules/ts-jest/dist/utils/messages.js
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
"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] : _); });
|
||||
}
|
||||
exports.interpolate = interpolate;
|
||||
1
node_modules/ts-jest/dist/utils/normalize-slashes.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/normalize-slashes.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
7
node_modules/ts-jest/dist/utils/normalize-slashes.js
generated
vendored
Normal file
7
node_modules/ts-jest/dist/utils/normalize-slashes.js
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.normalizeSlashes = void 0;
|
||||
function normalizeSlashes(value) {
|
||||
return value.replace(/\\/g, '/');
|
||||
}
|
||||
exports.normalizeSlashes = normalizeSlashes;
|
||||
1
node_modules/ts-jest/dist/utils/sha1.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/sha1.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
32
node_modules/ts-jest/dist/utils/sha1.js
generated
vendored
Normal file
32
node_modules/ts-jest/dist/utils/sha1.js
generated
vendored
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
"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() {
|
||||
var data = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
data[_i] = arguments[_i];
|
||||
}
|
||||
var canCache = data.length === 1 && typeof data[0] === 'string';
|
||||
var cacheKey;
|
||||
if (canCache) {
|
||||
cacheKey = data[0];
|
||||
if (cacheKey in exports.cache) {
|
||||
return exports.cache[cacheKey];
|
||||
}
|
||||
}
|
||||
var hash = crypto_1.createHash('sha1');
|
||||
data.forEach(function (item) {
|
||||
if (typeof item === 'string')
|
||||
hash.update(item, 'utf8');
|
||||
else
|
||||
hash.update(item);
|
||||
});
|
||||
var res = hash.digest('hex').toString();
|
||||
if (canCache) {
|
||||
exports.cache[cacheKey] = res;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
exports.sha1 = sha1;
|
||||
33
node_modules/ts-jest/dist/utils/testing.d.ts
generated
vendored
Normal file
33
node_modules/ts-jest/dist/utils/testing.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/// <reference types="jest" />
|
||||
export declare type MockableFunction = (...args: any[]) => any;
|
||||
export declare type MethodKeysOf<T> = {
|
||||
[K in keyof T]: T[K] extends MockableFunction ? K : never;
|
||||
}[keyof T];
|
||||
export declare type PropertyKeysOf<T> = {
|
||||
[K in keyof T]: T[K] extends MockableFunction ? never : K;
|
||||
}[keyof 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>;
|
||||
}
|
||||
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];
|
||||
};
|
||||
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];
|
||||
};
|
||||
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]>;
|
||||
};
|
||||
export declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
|
||||
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>;
|
||||
8
node_modules/ts-jest/dist/utils/testing.js
generated
vendored
Normal file
8
node_modules/ts-jest/dist/utils/testing.js
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.mocked = void 0;
|
||||
function mocked(item, _deep) {
|
||||
if (_deep === void 0) { _deep = false; }
|
||||
return item;
|
||||
}
|
||||
exports.mocked = mocked;
|
||||
1
node_modules/ts-jest/dist/utils/ts-error.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/ts-error.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
41
node_modules/ts-jest/dist/utils/ts-error.js
generated
vendored
Normal file
41
node_modules/ts-jest/dist/utils/ts-error.js
generated
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
"use strict";
|
||||
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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
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");
|
||||
var messages_1 = require("./messages");
|
||||
var logger = logger_1.rootLogger.child({ namespace: 'TSError' });
|
||||
exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
|
||||
var TSError = (function (_super) {
|
||||
__extends(TSError, _super);
|
||||
function TSError(diagnosticText, diagnosticCodes) {
|
||||
var _this = _super.call(this, messages_1.interpolate("{{diagnostics}}", {
|
||||
diagnostics: diagnosticText.trim(),
|
||||
})) || this;
|
||||
_this.diagnosticText = diagnosticText;
|
||||
_this.diagnosticCodes = diagnosticCodes;
|
||||
_this.name = 'TSError';
|
||||
logger.debug({ diagnosticCodes: diagnosticCodes, diagnosticText: diagnosticText }, 'created new TSError');
|
||||
Object.defineProperty(_this, 'stack', { value: '' });
|
||||
return _this;
|
||||
}
|
||||
TSError.prototype[exports.INSPECT_CUSTOM] = function () {
|
||||
return this.diagnosticText;
|
||||
};
|
||||
return TSError;
|
||||
}(make_error_1.BaseError));
|
||||
exports.TSError = TSError;
|
||||
1
node_modules/ts-jest/dist/utils/version-checkers.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/utils/version-checkers.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
60
node_modules/ts-jest/dist/utils/version-checkers.js
generated
vendored
Normal file
60
node_modules/ts-jest/dist/utils/version-checkers.js
generated
vendored
Normal 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;
|
||||
},
|
||||
};
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue