mirror of
https://github.com/actions/setup-java.git
synced 2025-04-21 02:16:45 +00:00
Fix.
This commit is contained in:
Stephen Franceschelli
parent
596a6da241
commit
c1a589c5b6
7078 changed files with 1882834 additions and 319 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 {};
|
||||
152
node_modules/ts-jest/dist/cli/config/init.js
generated
vendored
Normal file
152
node_modules/ts-jest/dist/cli/config/init.js
generated
vendored
Normal file
|
|
@ -0,0 +1,152 @@
|
|||
"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) {
|
||||
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) : new P(function (resolve) { resolve(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 _this = this;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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(_this, void 0, void 0, function () {
|
||||
var file, filePath, name, isPackage, exists, pkgFile, hasPackage, _a, jestPreset, askedTsconfig, force, jsdom, tsconfig, pkgJson, jsFilesProcessor, shouldPostProcessWithBabel, preset, body, base, tsJestConf, content;
|
||||
return __generator(this, function (_b) {
|
||||
file = args._[0] || 'jest.config.js';
|
||||
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({}, 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(_this, 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 {};
|
||||
220
node_modules/ts-jest/dist/cli/config/migrate.js
generated
vendored
Normal file
220
node_modules/ts-jest/dist/cli/config/migrate.js
generated
vendored
Normal file
|
|
@ -0,0 +1,220 @@
|
|||
"use strict";
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
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) : new P(function (resolve) { resolve(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 __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
var _this = this;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
|
||||
var fs_1 = require("fs");
|
||||
var json5_1 = require("json5");
|
||||
var path_1 = require("path");
|
||||
var backports_1 = require("../../util/backports");
|
||||
var presets_1 = require("../helpers/presets");
|
||||
exports.run = function (args) { return __awaiter(_this, void 0, void 0, function () {
|
||||
var nullLogger, file, filePath, footNotes, name, isPackage, actualConfig, migratedConfig, presetName, preset, jsTransformers, jsWithTs, jsWithBabel, presetValue, migratedValue, presetValue, migratedValue, before, after, stringify, prefix;
|
||||
return __generator(this, function (_a) {
|
||||
nullLogger = bs_logger_1.createLogger({ targets: [] });
|
||||
file = args._[0];
|
||||
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' ? presets_1.JestPresetNames.jsWIthBabel : presets_1.JestPresetNames.jsWithTs;
|
||||
}
|
||||
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 = presets_1.JestPresetNames.jsWIthBabel;
|
||||
}
|
||||
else if (jsWithTs && !jsWithBabel) {
|
||||
presetName = presets_1.JestPresetNames.jsWithTs;
|
||||
}
|
||||
else {
|
||||
presetName = presets_1.JestPresetNames.default;
|
||||
}
|
||||
}
|
||||
presetName = presetName || presets_1.JestPresetNames.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 &&
|
||||
fast_json_stable_stringify_1.default(migratedConfig.transform) === fast_json_stable_stringify_1.default(preset.value.transform)) {
|
||||
delete migratedConfig.transform;
|
||||
}
|
||||
cleanupConfig(actualConfig);
|
||||
cleanupConfig(migratedConfig);
|
||||
before = fast_json_stable_stringify_1.default(actualConfig);
|
||||
after = fast_json_stable_stringify_1.default(migratedConfig);
|
||||
if (after === before) {
|
||||
process.stderr.write("\nNo migration needed for given Jest configuration\n ");
|
||||
return [2];
|
||||
}
|
||||
stringify = /\.json$/.test(file) ? JSON.stringify : json5_1.stringify;
|
||||
prefix = /\.json$/.test(file) ? '"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 === presets_1.JestPresetNames.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(_this, 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 {};
|
||||
45
node_modules/ts-jest/dist/cli/help.js
generated
vendored
Normal file
45
node_modules/ts-jest/dist/cli/help.js
generated
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
"use strict";
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
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) : new P(function (resolve) { resolve(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 _this = this;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.run = function (_) { return __awaiter(_this, 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 {};
|
||||
39
node_modules/ts-jest/dist/cli/helpers/presets.js
generated
vendored
Normal file
39
node_modules/ts-jest/dist/cli/helpers/presets.js
generated
vendored
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var JestPresetNames;
|
||||
(function (JestPresetNames) {
|
||||
JestPresetNames["default"] = "ts-jest/presets/default";
|
||||
JestPresetNames["jsWithTs"] = "ts-jest/presets/js-with-ts";
|
||||
JestPresetNames["jsWIthBabel"] = "ts-jest/presets/js-with-babel";
|
||||
})(JestPresetNames = exports.JestPresetNames || (exports.JestPresetNames = {}));
|
||||
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 === JestPresetNames.default;
|
||||
},
|
||||
}); };
|
||||
exports.allPresets = {};
|
||||
exports.defaults = (exports.allPresets[JestPresetNames.default] = definePreset(JestPresetNames.default));
|
||||
exports.jsWithTs = (exports.allPresets[JestPresetNames.jsWithTs] = definePreset(JestPresetNames.jsWithTs));
|
||||
exports.jsWIthBabel = (exports.allPresets[JestPresetNames.jsWIthBabel] = definePreset(JestPresetNames.jsWIthBabel));
|
||||
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 {};
|
||||
105
node_modules/ts-jest/dist/cli/index.js
generated
vendored
Normal file
105
node_modules/ts-jest/dist/cli/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
"use strict";
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
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) : new P(function (resolve) { resolve(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 };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var _a;
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var yargs_parser_1 = __importDefault(require("yargs-parser"));
|
||||
var logger_1 = require("../util/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;
|
||||
1
node_modules/ts-jest/dist/compiler.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/compiler.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
233
node_modules/ts-jest/dist/compiler.js
generated
vendored
Normal file
233
node_modules/ts-jest/dist/compiler.js
generated
vendored
Normal file
|
|
@ -0,0 +1,233 @@
|
|||
"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 m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
|
||||
if (m) return m.call(o);
|
||||
return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
};
|
||||
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 __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var buffer_from_1 = __importDefault(require("buffer-from"));
|
||||
var stableStringify = require("fast-json-stable-stringify");
|
||||
var fs_1 = require("fs");
|
||||
var mkdirp = require("mkdirp");
|
||||
var path_1 = require("path");
|
||||
var messages_1 = require("./util/messages");
|
||||
var sha1_1 = require("./util/sha1");
|
||||
var hasOwn = Object.prototype.hasOwnProperty;
|
||||
function createCompiler(configs) {
|
||||
var e_1, _a, _b, _c;
|
||||
var logger = configs.logger.child({ namespace: 'ts-compiler' });
|
||||
logger.debug('creating typescript compiler', configs.tsJest.isolatedModules ? '(isolated modules)' : '(language service)');
|
||||
var cachedir = configs.tsCacheDir;
|
||||
var memoryCache = {
|
||||
contents: Object.create(null),
|
||||
versions: Object.create(null),
|
||||
outputs: Object.create(null),
|
||||
};
|
||||
var ts = configs.compilerModule;
|
||||
var cwd = configs.cwd;
|
||||
var extensions = ['.ts', '.tsx'];
|
||||
var _d = configs.typescript, compilerOptions = _d.options, fileNames = _d.fileNames;
|
||||
if (compilerOptions.allowJs) {
|
||||
extensions.push('.js');
|
||||
extensions.push('.jsx');
|
||||
}
|
||||
try {
|
||||
for (var fileNames_1 = __values(fileNames), fileNames_1_1 = fileNames_1.next(); !fileNames_1_1.done; fileNames_1_1 = fileNames_1.next()) {
|
||||
var path = fileNames_1_1.value;
|
||||
memoryCache.versions[path] = 1;
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (fileNames_1_1 && !fileNames_1_1.done && (_a = fileNames_1.return)) _a.call(fileNames_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
var getExtension = compilerOptions.jsx === ts.JsxEmit.Preserve
|
||||
? function (path) { return (/\.[tj]sx$/.test(path) ? '.jsx' : '.js'); }
|
||||
: function (_) { return '.js'; };
|
||||
var transformers = configs.tsCustomTransformers;
|
||||
var getOutput = function (code, fileName) {
|
||||
logger.debug({ fileName: fileName }, 'getOutput(): compiling as isolated module');
|
||||
var result = ts.transpileModule(code, {
|
||||
fileName: fileName,
|
||||
transformers: transformers,
|
||||
compilerOptions: compilerOptions,
|
||||
reportDiagnostics: configs.shouldReportDiagnostic(fileName),
|
||||
});
|
||||
if (result.diagnostics)
|
||||
configs.raiseDiagnostics(result.diagnostics, fileName, logger);
|
||||
return [result.outputText, result.sourceMapText];
|
||||
};
|
||||
var getTypeInfo = function (_code, _fileName, _position) {
|
||||
throw new TypeError(messages_1.Errors.TypesUnavailableWithoutTypeCheck);
|
||||
};
|
||||
if (!configs.tsJest.isolatedModules) {
|
||||
var updateMemoryCache_1 = function (code, fileName) {
|
||||
logger.debug({ fileName: fileName }, "updateMemoryCache()");
|
||||
if (memoryCache.contents[fileName] !== code) {
|
||||
memoryCache.contents[fileName] = code;
|
||||
memoryCache.versions[fileName] = (memoryCache.versions[fileName] || 0) + 1;
|
||||
}
|
||||
};
|
||||
var serviceHostDebugCtx = (_b = {},
|
||||
_b[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug,
|
||||
_b.namespace = 'ts:serviceHost',
|
||||
_b.call = null,
|
||||
_b);
|
||||
var serviceHostTraceCtx = __assign({}, serviceHostDebugCtx, (_c = {}, _c[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace, _c));
|
||||
var serviceHost = {
|
||||
getScriptFileNames: function () { return Object.keys(memoryCache.versions); },
|
||||
getScriptVersion: function (fileName) {
|
||||
var version = memoryCache.versions[fileName];
|
||||
return version === undefined ? undefined : String(version);
|
||||
},
|
||||
getScriptSnapshot: function (fileName) {
|
||||
var hit = hasOwn.call(memoryCache.contents, fileName);
|
||||
logger.trace({ fileName: fileName, cacheHit: hit }, "getScriptSnapshot():", 'cache', hit ? 'hit' : 'miss');
|
||||
if (!hit) {
|
||||
memoryCache.contents[fileName] = ts.sys.readFile(fileName);
|
||||
}
|
||||
var contents = memoryCache.contents[fileName];
|
||||
if (contents === undefined) {
|
||||
return;
|
||||
}
|
||||
return ts.ScriptSnapshot.fromString(contents);
|
||||
},
|
||||
fileExists: ts.sys.fileExists,
|
||||
readFile: logger.wrap(serviceHostTraceCtx, 'readFile', ts.sys.readFile),
|
||||
readDirectory: ts.sys.readDirectory,
|
||||
getDirectories: ts.sys.getDirectories,
|
||||
directoryExists: ts.sys.directoryExists,
|
||||
getNewLine: function () { return '\n'; },
|
||||
getCurrentDirectory: function () { return cwd; },
|
||||
getCompilationSettings: function () { return compilerOptions; },
|
||||
getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(compilerOptions); },
|
||||
getCustomTransformers: function () { return transformers; },
|
||||
};
|
||||
logger.debug('creating language service');
|
||||
var service_1 = ts.createLanguageService(serviceHost);
|
||||
getOutput = function (code, fileName) {
|
||||
logger.debug({ fileName: fileName }, 'getOutput(): compiling using language service');
|
||||
updateMemoryCache_1(code, fileName);
|
||||
var output = service_1.getEmitOutput(fileName);
|
||||
if (configs.shouldReportDiagnostic(fileName)) {
|
||||
logger.debug({ fileName: fileName }, 'getOutput(): computing diagnostics');
|
||||
var diagnostics = service_1
|
||||
.getCompilerOptionsDiagnostics()
|
||||
.concat(service_1.getSyntacticDiagnostics(fileName))
|
||||
.concat(service_1.getSemanticDiagnostics(fileName));
|
||||
configs.raiseDiagnostics(diagnostics, fileName, logger);
|
||||
}
|
||||
if (output.emitSkipped) {
|
||||
throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped");
|
||||
}
|
||||
if (output.outputFiles.length === 0) {
|
||||
throw new TypeError(messages_1.interpolate(messages_1.Errors.UnableToRequireDefinitionFile, {
|
||||
file: path_1.basename(fileName),
|
||||
}));
|
||||
}
|
||||
return [output.outputFiles[1].text, output.outputFiles[0].text];
|
||||
};
|
||||
getTypeInfo = function (code, fileName, position) {
|
||||
updateMemoryCache_1(code, fileName);
|
||||
var info = service_1.getQuickInfoAtPosition(fileName, position);
|
||||
var name = ts.displayPartsToString(info ? info.displayParts : []);
|
||||
var comment = ts.displayPartsToString(info ? info.documentation : []);
|
||||
return { name: name, comment: comment };
|
||||
};
|
||||
}
|
||||
var compile = readThrough(cachedir, memoryCache, getOutput, getExtension, cwd, logger);
|
||||
return { cwd: cwd, compile: compile, getTypeInfo: getTypeInfo, extensions: extensions, cachedir: cachedir, ts: ts };
|
||||
}
|
||||
exports.createCompiler = createCompiler;
|
||||
function readThrough(cachedir, memoryCache, compile, getExtension, cwd, logger) {
|
||||
if (!cachedir) {
|
||||
return function (code, fileName, lineOffset) {
|
||||
logger.debug({ fileName: fileName }, 'readThrough(): no cache');
|
||||
var _a = __read(compile(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
|
||||
var output = updateOutput(value, fileName, sourceMap, getExtension, cwd);
|
||||
memoryCache.outputs[fileName] = output;
|
||||
return output;
|
||||
};
|
||||
}
|
||||
mkdirp.sync(cachedir);
|
||||
return function (code, fileName, lineOffset) {
|
||||
var cachePath = path_1.join(cachedir, getCacheName(code, fileName));
|
||||
var extension = getExtension(fileName);
|
||||
var outputPath = "" + cachePath + extension;
|
||||
try {
|
||||
var output_1 = fs_1.readFileSync(outputPath, 'utf8');
|
||||
if (isValidCacheContent(output_1)) {
|
||||
logger.debug({ fileName: fileName }, 'readThrough(): cache hit');
|
||||
memoryCache.outputs[fileName] = output_1;
|
||||
return output_1;
|
||||
}
|
||||
}
|
||||
catch (err) { }
|
||||
logger.debug({ fileName: fileName }, 'readThrough(): cache miss');
|
||||
var _a = __read(compile(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
|
||||
var output = updateOutput(value, fileName, sourceMap, getExtension, cwd);
|
||||
logger.debug({ fileName: fileName, outputPath: outputPath }, 'readThrough(): writing caches');
|
||||
memoryCache.outputs[fileName] = output;
|
||||
fs_1.writeFileSync(outputPath, output);
|
||||
return output;
|
||||
};
|
||||
}
|
||||
function updateOutput(outputText, fileName, sourceMap, getExtension, sourceRoot) {
|
||||
var base = path_1.basename(fileName);
|
||||
var base64Map = buffer_from_1.default(updateSourceMap(sourceMap, fileName, sourceRoot), 'utf8').toString('base64');
|
||||
var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
|
||||
var sourceMapLength = (base + ".map").length + (getExtension(fileName).length - path_1.extname(fileName).length);
|
||||
return outputText.slice(0, -sourceMapLength) + sourceMapContent;
|
||||
}
|
||||
function updateSourceMap(sourceMapText, fileName, _sourceRoot) {
|
||||
var sourceMap = JSON.parse(sourceMapText);
|
||||
sourceMap.file = fileName;
|
||||
sourceMap.sources = [fileName];
|
||||
delete sourceMap.sourceRoot;
|
||||
return stableStringify(sourceMap);
|
||||
}
|
||||
function getCacheName(sourceCode, fileName) {
|
||||
return sha1_1.sha1(path_1.extname(fileName), '\x00', sourceCode);
|
||||
}
|
||||
function isValidCacheContent(contents) {
|
||||
return /(?:9|0=|Q==)$/.test(contents.slice(-3));
|
||||
}
|
||||
36
node_modules/ts-jest/dist/config/config-set.d.ts
generated
vendored
Normal file
36
node_modules/ts-jest/dist/config/config-set.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
/// <reference types="jest" />
|
||||
import { Logger } from 'bs-logger';
|
||||
import { CompilerOptions, CustomTransformers, ParsedCommandLine } from 'typescript';
|
||||
import { AstTransformerDesc, BabelConfig, BabelJestTransformer, TTypeScript, TsCompiler, TsJestConfig, TsJestGlobalOptions, TsJestHooksMap } from '../types';
|
||||
export declare class ConfigSet {
|
||||
readonly parentOptions?: TsJestGlobalOptions | undefined;
|
||||
readonly projectPackageJson: Record<string, any>;
|
||||
readonly projectDependencies: Record<string, string>;
|
||||
readonly jest: jest.ProjectConfig;
|
||||
readonly tsJest: TsJestConfig;
|
||||
readonly typescript: ParsedCommandLine;
|
||||
readonly tsconfig: any;
|
||||
readonly versions: Record<string, string>;
|
||||
private static loadConfig;
|
||||
readonly babel: BabelConfig | undefined;
|
||||
readonly compilerModule: TTypeScript;
|
||||
readonly babelJestTransformer: BabelJestTransformer | undefined;
|
||||
readonly tsCompiler: TsCompiler;
|
||||
readonly astTransformers: AstTransformerDesc[];
|
||||
readonly tsCustomTransformers: CustomTransformers;
|
||||
readonly hooks: TsJestHooksMap;
|
||||
readonly shouldReportDiagnostic: (filePath: string) => boolean;
|
||||
readonly shouldStringifyContent: (filePath: string) => boolean;
|
||||
readonly tsCacheDir: string | undefined;
|
||||
readonly overriddenCompilerOptions: Partial<CompilerOptions>;
|
||||
readonly rootDir: string;
|
||||
readonly cwd: string;
|
||||
readonly tsJestDigest: string;
|
||||
readonly cacheKey: string;
|
||||
readonly logger: Logger;
|
||||
constructor(jestConfig: jest.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
|
||||
resolvePath(inputPath: string, { throwIfMissing, nodeResolve }?: {
|
||||
throwIfMissing?: boolean;
|
||||
nodeResolve?: boolean;
|
||||
}): string;
|
||||
}
|
||||
794
node_modules/ts-jest/dist/config/config-set.js
generated
vendored
Normal file
794
node_modules/ts-jest/dist/config/config-set.js
generated
vendored
Normal file
|
|
@ -0,0 +1,794 @@
|
|||
"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 m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
|
||||
if (m) return m.call(o);
|
||||
return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
};
|
||||
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 __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var fs_1 = require("fs");
|
||||
var json5_1 = __importDefault(require("json5"));
|
||||
var path_1 = require("path");
|
||||
var semver_1 = __importDefault(require("semver"));
|
||||
var __1 = require("..");
|
||||
var compiler_1 = require("../compiler");
|
||||
var transformers_1 = require("../transformers");
|
||||
var backports_1 = require("../util/backports");
|
||||
var get_package_version_1 = require("../util/get-package-version");
|
||||
var importer_1 = require("../util/importer");
|
||||
var json_1 = require("../util/json");
|
||||
var jsonable_value_1 = require("../util/jsonable-value");
|
||||
var logger_1 = require("../util/logger");
|
||||
var memoize_1 = require("../util/memoize");
|
||||
var messages_1 = require("../util/messages");
|
||||
var normalize_slashes_1 = require("../util/normalize-slashes");
|
||||
var sha1_1 = require("../util/sha1");
|
||||
var ts_error_1 = require("../util/ts-error");
|
||||
var logger = logger_1.rootLogger.child({ namespace: 'config' });
|
||||
exports.MATCH_NOTHING = /a^/;
|
||||
exports.IGNORE_DIAGNOSTIC_CODES = [
|
||||
6059,
|
||||
18002,
|
||||
18003,
|
||||
];
|
||||
var DiagnosticCodes;
|
||||
(function (DiagnosticCodes) {
|
||||
DiagnosticCodes[DiagnosticCodes["TsJest"] = 151000] = "TsJest";
|
||||
DiagnosticCodes[DiagnosticCodes["ConfigModuleOption"] = 151001] = "ConfigModuleOption";
|
||||
})(DiagnosticCodes = exports.DiagnosticCodes || (exports.DiagnosticCodes = {}));
|
||||
var normalizeRegex = function (pattern) {
|
||||
return pattern ? (typeof pattern === 'string' ? pattern : pattern.source) : undefined;
|
||||
};
|
||||
var toDiagnosticCode = function (code) {
|
||||
return code ? parseInt(("" + code).trim().replace(/^TS/, ''), 10) || undefined : undefined;
|
||||
};
|
||||
var toDiagnosticCodeList = function (items, into) {
|
||||
if (into === void 0) { into = []; }
|
||||
var e_1, _a;
|
||||
if (!Array.isArray(items))
|
||||
items = [items];
|
||||
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 (!item)
|
||||
continue;
|
||||
if (Array.isArray(item)) {
|
||||
toDiagnosticCodeList(item, into);
|
||||
continue;
|
||||
}
|
||||
else 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, parentOptions, parentLogger) {
|
||||
var _a;
|
||||
this.parentOptions = parentOptions;
|
||||
this._jestConfig = jestConfig;
|
||||
this.logger = parentLogger ? parentLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'config', _a)) : logger;
|
||||
}
|
||||
Object.defineProperty(ConfigSet.prototype, "projectPackageJson", {
|
||||
get: function () {
|
||||
var packageJson = this.tsJest.packageJson;
|
||||
if (packageJson && packageJson.kind === 'inline') {
|
||||
return packageJson.value;
|
||||
}
|
||||
if (packageJson && packageJson.kind === 'file' && packageJson.value) {
|
||||
var path = this.resolvePath(packageJson.value);
|
||||
if (fs_1.existsSync(path)) {
|
||||
return require(path);
|
||||
}
|
||||
this.logger.warn(messages_1.Errors.UnableToFindProjectRoot);
|
||||
return {};
|
||||
}
|
||||
var tsJestRoot = path_1.resolve(__dirname, '..', '..');
|
||||
var pkgPath = path_1.resolve(tsJestRoot, '..', '..', 'package.json');
|
||||
if (fs_1.existsSync(pkgPath)) {
|
||||
return require(pkgPath);
|
||||
}
|
||||
if (fs_1.realpathSync(this.rootDir) === fs_1.realpathSync(tsJestRoot)) {
|
||||
pkgPath = path_1.resolve(tsJestRoot, 'package.json');
|
||||
if (fs_1.existsSync(pkgPath)) {
|
||||
return require(pkgPath);
|
||||
}
|
||||
}
|
||||
this.logger.warn(messages_1.Errors.UnableToFindProjectRoot);
|
||||
return {};
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "projectDependencies", {
|
||||
get: function () {
|
||||
var pkg = this.projectPackageJson;
|
||||
var names = Object.keys(__assign({}, pkg.optionalDependencies, pkg.peerDependencies, pkg.devDependencies, pkg.dependencies));
|
||||
return names.reduce(function (map, name) {
|
||||
var version = get_package_version_1.getPackageVersion(name);
|
||||
if (version)
|
||||
map[name] = version;
|
||||
return map;
|
||||
}, {});
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "jest", {
|
||||
get: function () {
|
||||
var config = backports_1.backportJestConfig(this.logger, this._jestConfig);
|
||||
if (this.parentOptions) {
|
||||
var globals = config.globals || (config.globals = {});
|
||||
globals['ts-jest'] = __assign({}, this.parentOptions, globals['ts-jest']);
|
||||
}
|
||||
this.logger.debug({ jestConfig: config }, 'normalized jest config');
|
||||
return config;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsJest", {
|
||||
get: function () {
|
||||
var _this = this;
|
||||
var parsedConfig = this.jest;
|
||||
var _a = parsedConfig.globals, globals = _a === void 0 ? {} : _a;
|
||||
var options = __assign({}, globals['ts-jest']);
|
||||
var tsConfigOpt = options.tsConfig;
|
||||
var tsConfig;
|
||||
if (typeof tsConfigOpt === 'string' || tsConfigOpt == null || tsConfigOpt === true) {
|
||||
tsConfig = {
|
||||
kind: 'file',
|
||||
value: typeof tsConfigOpt === 'string' ? this.resolvePath(tsConfigOpt) : undefined,
|
||||
};
|
||||
}
|
||||
else if (typeof tsConfigOpt === 'object') {
|
||||
tsConfig = {
|
||||
kind: 'inline',
|
||||
value: tsConfigOpt,
|
||||
};
|
||||
}
|
||||
var packageJsonOpt = options.packageJson;
|
||||
var packageJson;
|
||||
if (typeof packageJsonOpt === 'string' || packageJsonOpt == null || packageJsonOpt === true) {
|
||||
packageJson = {
|
||||
kind: 'file',
|
||||
value: typeof packageJsonOpt === 'string' ? this.resolvePath(packageJsonOpt) : undefined,
|
||||
};
|
||||
}
|
||||
else if (typeof packageJsonOpt === 'object') {
|
||||
packageJson = {
|
||||
kind: 'inline',
|
||||
value: packageJsonOpt,
|
||||
};
|
||||
}
|
||||
var transformers = (options.astTransformers || []).map(function (mod) { return _this.resolvePath(mod, { nodeResolve: true }); });
|
||||
var babelConfigOpt = options.babelConfig;
|
||||
var babelConfig;
|
||||
if (typeof babelConfigOpt === 'string' || babelConfigOpt === true) {
|
||||
babelConfig = {
|
||||
kind: 'file',
|
||||
value: babelConfigOpt === true ? undefined : this.resolvePath(babelConfigOpt),
|
||||
};
|
||||
}
|
||||
else if (babelConfigOpt) {
|
||||
babelConfig = {
|
||||
kind: 'inline',
|
||||
value: babelConfigOpt,
|
||||
};
|
||||
}
|
||||
var diagnostics;
|
||||
var _b = options.diagnostics, diagnosticsOpt = _b === void 0 ? true : _b;
|
||||
var ignoreList = [exports.IGNORE_DIAGNOSTIC_CODES, process.env.TS_JEST_IGNORE_DIAGNOSTICS];
|
||||
if (diagnosticsOpt === true || diagnosticsOpt == null) {
|
||||
diagnostics = { ignoreCodes: [], pretty: true, throws: true };
|
||||
}
|
||||
else if (diagnosticsOpt === false) {
|
||||
diagnostics = {
|
||||
throws: false,
|
||||
pretty: true,
|
||||
ignoreCodes: [],
|
||||
pathRegex: exports.MATCH_NOTHING.source,
|
||||
};
|
||||
}
|
||||
else {
|
||||
ignoreList.push(diagnosticsOpt.ignoreCodes);
|
||||
diagnostics = {
|
||||
pretty: diagnosticsOpt.pretty == null ? true : !!diagnosticsOpt.pretty,
|
||||
ignoreCodes: [],
|
||||
pathRegex: normalizeRegex(diagnosticsOpt.pathRegex),
|
||||
throws: !diagnosticsOpt.warnOnly,
|
||||
};
|
||||
}
|
||||
diagnostics.ignoreCodes = toDiagnosticCodeList(ignoreList);
|
||||
var stringifyContentPathRegex = normalizeRegex(options.stringifyContentPathRegex);
|
||||
var res = {
|
||||
tsConfig: tsConfig,
|
||||
packageJson: packageJson,
|
||||
babelConfig: babelConfig,
|
||||
diagnostics: diagnostics,
|
||||
isolatedModules: !!options.isolatedModules,
|
||||
compiler: options.compiler || 'typescript',
|
||||
transformers: transformers,
|
||||
stringifyContentPathRegex: stringifyContentPathRegex,
|
||||
};
|
||||
this.logger.debug({ tsJestConfig: res }, 'normalized ts-jest config');
|
||||
return res;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "typescript", {
|
||||
get: function () {
|
||||
return this._typescript.resolved;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsconfig", {
|
||||
get: function () {
|
||||
return this._typescript.input;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "versions", {
|
||||
get: function () {
|
||||
var modules = ['jest', this.tsJest.compiler];
|
||||
if (this.tsJest.babelConfig) {
|
||||
modules.push('@babel/core', 'babel-jest');
|
||||
}
|
||||
return modules.reduce(function (map, name) {
|
||||
map[name] = get_package_version_1.getPackageVersion(name) || '-';
|
||||
return map;
|
||||
}, { 'ts-jest': __1.version });
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "_typescript", {
|
||||
get: function () {
|
||||
var tsConfig = this.tsJest.tsConfig;
|
||||
var configFilePath = tsConfig && tsConfig.kind === 'file' ? tsConfig.value : undefined;
|
||||
var result = this.readTsConfig(tsConfig && tsConfig.kind === 'inline' ? tsConfig.value : undefined, configFilePath, tsConfig == null);
|
||||
this.raiseDiagnostics(result.resolved.errors, configFilePath);
|
||||
this.logger.debug({ tsconfig: result }, 'normalized typescript config');
|
||||
return result;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "raiseDiagnostics", {
|
||||
get: function () {
|
||||
var _this = this;
|
||||
var _a = this, createTsError = _a.createTsError, filterDiagnostics = _a.filterDiagnostics, throws = _a.tsJest.diagnostics.throws, DiagnosticCategory = _a.compilerModule.DiagnosticCategory;
|
||||
return function (diagnostics, filePath, logger) {
|
||||
if (logger === void 0) { logger = _this.logger; }
|
||||
var filteredDiagnostics = filterDiagnostics(diagnostics, filePath);
|
||||
if (filteredDiagnostics.length === 0)
|
||||
return;
|
||||
var error = createTsError(filteredDiagnostics);
|
||||
var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
|
||||
if (throws && filteredDiagnostics.some(function (d) { return importantCategories.includes(d.category); })) {
|
||||
throw error;
|
||||
}
|
||||
logger.warn({ error: error }, error.message);
|
||||
};
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
ConfigSet.loadConfig = function (base) {
|
||||
var _a = importer_1.importer.babelCore(messages_1.ImportReasons.BabelJest), OptionManager = _a.OptionManager, loadPartialConfig = _a.loadPartialConfig, version = _a.version;
|
||||
if (version && semver_1.default.satisfies(version, '>=6 <7')) {
|
||||
delete base.cwd;
|
||||
}
|
||||
if (typeof loadPartialConfig === 'function') {
|
||||
var partialConfig = loadPartialConfig(base);
|
||||
if (partialConfig) {
|
||||
return partialConfig.options;
|
||||
}
|
||||
}
|
||||
return new OptionManager().init(base);
|
||||
};
|
||||
Object.defineProperty(ConfigSet.prototype, "babel", {
|
||||
get: function () {
|
||||
var babelConfig = this.tsJest.babelConfig;
|
||||
if (babelConfig == null) {
|
||||
this.logger.debug('babel is disabled');
|
||||
return;
|
||||
}
|
||||
var base = { cwd: this.cwd };
|
||||
if (babelConfig.kind === 'file') {
|
||||
if (babelConfig.value) {
|
||||
base = __assign({}, base, json5_1.default.parse(fs_1.readFileSync(babelConfig.value, 'utf8')));
|
||||
}
|
||||
}
|
||||
else if (babelConfig.kind === 'inline') {
|
||||
base = __assign({}, base, babelConfig.value);
|
||||
}
|
||||
var config = ConfigSet.loadConfig(base);
|
||||
this.logger.debug({ babelConfig: config }, 'normalized babel config');
|
||||
return config;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "compilerModule", {
|
||||
get: function () {
|
||||
return importer_1.importer.typescript(messages_1.ImportReasons.TsJest, this.tsJest.compiler);
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "babelJestTransformer", {
|
||||
get: function () {
|
||||
var babel = this.babel;
|
||||
if (!babel)
|
||||
return;
|
||||
this.logger.debug('creating babel-jest transformer');
|
||||
return importer_1.importer.babelJest(messages_1.ImportReasons.BabelJest).createTransformer(babel);
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsCompiler", {
|
||||
get: function () {
|
||||
return compiler_1.createCompiler(this);
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "astTransformers", {
|
||||
get: function () {
|
||||
return __spread(transformers_1.internals, this.tsJest.transformers.map(function (m) { return require(m); }));
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsCustomTransformers", {
|
||||
get: function () {
|
||||
var _this = this;
|
||||
return {
|
||||
before: this.astTransformers.map(function (t) { return t.factory(_this); }),
|
||||
};
|
||||
},
|
||||
enumerable: true,
|
||||
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: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "filterDiagnostics", {
|
||||
get: function () {
|
||||
var _a = this, ignoreCodes = _a.tsJest.diagnostics.ignoreCodes, shouldReportDiagnostic = _a.shouldReportDiagnostic;
|
||||
return function (diagnostics, filePath) {
|
||||
if (filePath && !shouldReportDiagnostic(filePath))
|
||||
return [];
|
||||
return diagnostics.filter(function (diagnostic) {
|
||||
if (diagnostic.file && diagnostic.file.fileName && !shouldReportDiagnostic(diagnostic.file.fileName)) {
|
||||
return false;
|
||||
}
|
||||
return ignoreCodes.indexOf(diagnostic.code) === -1;
|
||||
});
|
||||
};
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "shouldReportDiagnostic", {
|
||||
get: function () {
|
||||
var pathRegex = this.tsJest.diagnostics.pathRegex;
|
||||
if (pathRegex) {
|
||||
var regex_1 = new RegExp(pathRegex);
|
||||
return function (file) { return regex_1.test(file); };
|
||||
}
|
||||
else {
|
||||
return function () { return true; };
|
||||
}
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "shouldStringifyContent", {
|
||||
get: function () {
|
||||
var stringifyContentPathRegex = this.tsJest.stringifyContentPathRegex;
|
||||
if (stringifyContentPathRegex) {
|
||||
var regex_2 = new RegExp(stringifyContentPathRegex);
|
||||
return function (file) { return regex_2.test(file); };
|
||||
}
|
||||
else {
|
||||
return function () { return false; };
|
||||
}
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "createTsError", {
|
||||
get: function () {
|
||||
var _this = this;
|
||||
var pretty = this.tsJest.diagnostics.pretty;
|
||||
var formatDiagnostics = pretty
|
||||
? this.compilerModule.formatDiagnosticsWithColorAndContext
|
||||
: this.compilerModule.formatDiagnostics;
|
||||
var diagnosticHost = {
|
||||
getNewLine: function () { return '\n'; },
|
||||
getCurrentDirectory: function () { return _this.cwd; },
|
||||
getCanonicalFileName: function (path) { return path; },
|
||||
};
|
||||
return function (diagnostics) {
|
||||
var diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
|
||||
var diagnosticCodes = diagnostics.map(function (x) { return x.code; });
|
||||
return new ts_error_1.TSError(diagnosticText, diagnosticCodes);
|
||||
};
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsCacheDir", {
|
||||
get: function () {
|
||||
if (!this.jest.cache) {
|
||||
logger.debug('file caching disabled');
|
||||
return;
|
||||
}
|
||||
var cacheSuffix = sha1_1.sha1(json_1.stringify({
|
||||
version: this.compilerModule.version,
|
||||
digest: this.tsJestDigest,
|
||||
dependencies: this.projectDependencies,
|
||||
compiler: this.tsJest.compiler,
|
||||
compilerOptions: this.typescript.options,
|
||||
isolatedModules: this.tsJest.isolatedModules,
|
||||
diagnostics: this.tsJest.diagnostics,
|
||||
}));
|
||||
var res = path_1.join(this.jest.cacheDirectory, 'ts-jest', cacheSuffix.substr(0, 2), cacheSuffix.substr(2));
|
||||
logger.debug({ cacheDirectory: res }, 'will use file caching');
|
||||
return res;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "overriddenCompilerOptions", {
|
||||
get: function () {
|
||||
var options = {
|
||||
sourceMap: true,
|
||||
inlineSourceMap: false,
|
||||
inlineSources: true,
|
||||
declaration: false,
|
||||
noEmit: false,
|
||||
outDir: '$$ts-jest$$',
|
||||
removeComments: false,
|
||||
out: undefined,
|
||||
outFile: undefined,
|
||||
composite: undefined,
|
||||
declarationDir: undefined,
|
||||
declarationMap: undefined,
|
||||
emitDeclarationOnly: undefined,
|
||||
sourceRoot: undefined,
|
||||
};
|
||||
if (!this.tsJest.babelConfig) {
|
||||
options.module = this.compilerModule.ModuleKind.CommonJS;
|
||||
}
|
||||
return options;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "rootDir", {
|
||||
get: function () {
|
||||
return path_1.normalize(this.jest.rootDir || this.cwd);
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "cwd", {
|
||||
get: function () {
|
||||
return path_1.normalize(this.jest.cwd || process.cwd());
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "isDoctoring", {
|
||||
get: function () {
|
||||
return !!process.env.TS_JEST_DOCTOR;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "tsJestDigest", {
|
||||
get: function () {
|
||||
return __1.digest;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "jsonValue", {
|
||||
get: function () {
|
||||
var jest = __assign({}, this.jest);
|
||||
var globals = (jest.globals = __assign({}, jest.globals));
|
||||
delete jest.name;
|
||||
delete jest.cacheDirectory;
|
||||
delete globals['ts-jest'];
|
||||
return new jsonable_value_1.JsonableValue({
|
||||
versions: this.versions,
|
||||
projectDepVersions: this.projectDependencies,
|
||||
digest: this.tsJestDigest,
|
||||
transformers: this.astTransformers.map(function (t) { return t.name + "@" + t.version; }),
|
||||
jest: jest,
|
||||
tsJest: this.tsJest,
|
||||
babel: this.babel,
|
||||
tsconfig: this.typescript.options,
|
||||
});
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ConfigSet.prototype, "cacheKey", {
|
||||
get: function () {
|
||||
return this.jsonValue.serialized;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
ConfigSet.prototype.makeDiagnostic = function (code, messageText, options) {
|
||||
if (options === void 0) { options = {}; }
|
||||
var _a = options.category, category = _a === void 0 ? this.compilerModule.DiagnosticCategory.Warning : _a, file = options.file, start = options.start, length = options.length;
|
||||
return {
|
||||
code: code,
|
||||
messageText: messageText,
|
||||
category: category,
|
||||
file: file,
|
||||
start: start,
|
||||
length: length,
|
||||
};
|
||||
};
|
||||
ConfigSet.prototype.readTsConfig = function (compilerOptions, resolvedConfigFile, noProject) {
|
||||
var e_2, _a;
|
||||
var config = { compilerOptions: {} };
|
||||
var basePath = normalize_slashes_1.normalizeSlashes(this.rootDir);
|
||||
var configFileName;
|
||||
var ts = this.compilerModule;
|
||||
var input;
|
||||
if (noProject) {
|
||||
input = { compilerOptions: __assign({}, compilerOptions) };
|
||||
}
|
||||
else {
|
||||
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 {
|
||||
resolved: { errors: [result_1.error], fileNames: [], options: {} },
|
||||
};
|
||||
}
|
||||
config = result_1.config;
|
||||
input = __assign({}, result_1.config, { compilerOptions: __assign({}, (result_1.config && result_1.config.compilerOptions), compilerOptions) });
|
||||
basePath = normalize_slashes_1.normalizeSlashes(path_1.dirname(configFileName));
|
||||
}
|
||||
}
|
||||
config.compilerOptions = __assign({}, config.compilerOptions, compilerOptions);
|
||||
var result = ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName);
|
||||
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(this.makeDiagnostic(DiagnosticCodes.ConfigModuleOption, messages_1.Errors.ConfigNoModuleInterop, {
|
||||
category: ts.DiagnosticCategory.Message,
|
||||
}));
|
||||
if (!('allowSyntheticDefaultImports' in config.compilerOptions)) {
|
||||
finalOptions.allowSyntheticDefaultImports = true;
|
||||
}
|
||||
}
|
||||
try {
|
||||
for (var _b = __values(Object.keys(forcedOptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.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 (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
return { input: input, resolved: result };
|
||||
};
|
||||
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(messages_1.Errors.FileNotFound, { inputPath: inputPath, resolvedPath: path }));
|
||||
}
|
||||
this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
|
||||
return path;
|
||||
};
|
||||
ConfigSet.prototype.toJSON = function () {
|
||||
return this.jsonValue.value;
|
||||
};
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "projectPackageJson", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "projectDependencies", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "jest", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsJest", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "versions", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "_typescript", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "raiseDiagnostics", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "babel", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "compilerModule", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "babelJestTransformer", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsCompiler", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "astTransformers", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsCustomTransformers", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "hooks", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "filterDiagnostics", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "shouldReportDiagnostic", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "shouldStringifyContent", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "createTsError", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsCacheDir", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "overriddenCompilerOptions", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "rootDir", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "cwd", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "tsJestDigest", null);
|
||||
__decorate([
|
||||
memoize_1.Memoize()
|
||||
], ConfigSet.prototype, "jsonValue", null);
|
||||
return ConfigSet;
|
||||
}());
|
||||
exports.ConfigSet = ConfigSet;
|
||||
10
node_modules/ts-jest/dist/config/create-jest-preset.d.ts
generated
vendored
Normal file
10
node_modules/ts-jest/dist/config/create-jest-preset.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
/// <reference types="jest" />
|
||||
export interface TsJestPresets {
|
||||
transform: Record<string, string>;
|
||||
testMatch?: string[];
|
||||
moduleFileExtensions?: string[];
|
||||
}
|
||||
export interface CreateJestPresetOptions {
|
||||
allowJs?: boolean;
|
||||
}
|
||||
export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: jest.InitialOptions): TsJestPresets;
|
||||
23
node_modules/ts-jest/dist/config/create-jest-preset.js
generated
vendored
Normal file
23
node_modules/ts-jest/dist/config/create-jest-preset.js
generated
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
"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 });
|
||||
var logger_1 = require("../util/logger");
|
||||
var logger = logger_1.rootLogger.child({ namespace: 'jest-preset' });
|
||||
function createJestPreset(_a, from) {
|
||||
var _b = (_a === void 0 ? {} : _a).allowJs, allowJs = _b === void 0 ? false : _b;
|
||||
if (from === void 0) { from = {}; }
|
||||
var _c;
|
||||
logger.debug({ allowJs: allowJs }, 'creating jest presets', allowJs ? 'handling' : 'not handling', 'JavaScript files');
|
||||
return __assign({ transform: __assign({}, from.transform, (_c = {}, _c[allowJs ? '^.+\\.[tj]sx?$' : '^.+\\.tsx?$'] = 'ts-jest', _c)) }, (from.testMatch ? { testMatch: from.testMatch } : undefined), (from.moduleFileExtensions ? { moduleFileExtensions: from.moduleFileExtensions } : undefined));
|
||||
}
|
||||
exports.createJestPreset = createJestPreset;
|
||||
5
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts
generated
vendored
Normal file
5
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
|
||||
prefix?: string | undefined;
|
||||
}) => {
|
||||
[key: string]: string;
|
||||
} | undefined;
|
||||
62
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js
generated
vendored
Normal file
62
node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js
generated
vendored
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
"use strict";
|
||||
var __values = (this && this.__values) || function (o) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
|
||||
if (m) return m.call(o);
|
||||
return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var _a;
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var logger_1 = require("../util/logger");
|
||||
var messages_1 = require("../util/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 _b = (_a === void 0 ? {} : _a).prefix, prefix = _b === void 0 ? '' : _b;
|
||||
var e_1, _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(messages_1.Errors.NotMappingPathWithEmptyMap, { path: fromPath }));
|
||||
continue;
|
||||
}
|
||||
else if (toPaths.length > 1) {
|
||||
logger.warn(messages_1.interpolate(messages_1.Errors.MappingOnlyFirstTargetOfPath, {
|
||||
path: fromPath,
|
||||
count: toPaths.length,
|
||||
}));
|
||||
}
|
||||
var target = toPaths[0];
|
||||
var segments = fromPath.split(/\*/g);
|
||||
if (segments.length === 1) {
|
||||
pattern = "^" + escapeRegex(fromPath) + "$";
|
||||
jestMap[pattern] = "" + prefix + target;
|
||||
}
|
||||
else if (segments.length === 2) {
|
||||
pattern = "^" + escapeRegex(segments[0]) + "(.*)" + escapeRegex(segments[1]) + "$";
|
||||
jestMap[pattern] = "" + prefix + target.replace(/\*/g, '$1');
|
||||
}
|
||||
else {
|
||||
logger.warn(messages_1.interpolate(messages_1.Errors.NotMappingMultiStarPath, { path: fromPath }));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
return jestMap;
|
||||
};
|
||||
16
node_modules/ts-jest/dist/index.d.ts
generated
vendored
Normal file
16
node_modules/ts-jest/dist/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
import { createJestPreset as createJestPresetCore } from './config/create-jest-preset';
|
||||
import { TsJestTransformer } from './ts-jest-transformer';
|
||||
import { TsJestGlobalOptions } from './types';
|
||||
import { mocked as mockedCore } from './util/testing';
|
||||
export declare const mocked: typeof mockedCore;
|
||||
export declare const createJestPreset: typeof createJestPresetCore;
|
||||
export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
|
||||
prefix?: string | undefined;
|
||||
}) => {
|
||||
[key: string]: string;
|
||||
} | undefined;
|
||||
export declare const version: string;
|
||||
export declare const digest: string;
|
||||
export declare function createTransformer(baseConfig?: TsJestGlobalOptions): TsJestTransformer;
|
||||
declare const jestPreset: import("./config/create-jest-preset").TsJestPresets;
|
||||
export { jestPreset, };
|
||||
74
node_modules/ts-jest/dist/index.js
generated
vendored
Normal file
74
node_modules/ts-jest/dist/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spread = (this && this.__spread) || function () {
|
||||
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
|
||||
return ar;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var _a;
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var fs_1 = require("fs");
|
||||
var path_1 = require("path");
|
||||
var create_jest_preset_1 = require("./config/create-jest-preset");
|
||||
var paths_to_module_name_mapper_1 = require("./config/paths-to-module-name-mapper");
|
||||
var ts_jest_transformer_1 = require("./ts-jest-transformer");
|
||||
var logger_1 = require("./util/logger");
|
||||
var messages_1 = require("./util/messages");
|
||||
var testing_1 = require("./util/testing");
|
||||
var version_checkers_1 = require("./util/version-checkers");
|
||||
var 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(messages_1.Deprecateds.HelperMovedToUtils, { 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);
|
||||
exports.version = require('../package.json').version;
|
||||
exports.digest = fs_1.readFileSync(path_1.resolve(__dirname, '..', '.ts-jest-digest'), 'utf8');
|
||||
var transformer;
|
||||
function defaultTransformer() {
|
||||
return transformer || (transformer = createTransformer());
|
||||
}
|
||||
function createTransformer(baseConfig) {
|
||||
version_checkers_1.VersionCheckers.jest.warn();
|
||||
return new ts_jest_transformer_1.TsJestTransformer(baseConfig);
|
||||
}
|
||||
exports.createTransformer = createTransformer;
|
||||
function process() {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
var _a;
|
||||
return (_a = defaultTransformer()).process.apply(_a, __spread(args));
|
||||
}
|
||||
exports.process = process;
|
||||
function getCacheKey() {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
var _a;
|
||||
return (_a = defaultTransformer()).getCacheKey.apply(_a, __spread(args));
|
||||
}
|
||||
exports.getCacheKey = getCacheKey;
|
||||
exports.canInstrument = false;
|
||||
var jestPreset = create_jest_preset_1.createJestPreset();
|
||||
exports.jestPreset = jestPreset;
|
||||
exports.__singleton = function () { return transformer; };
|
||||
exports.__resetModule = function () { return (transformer = undefined); };
|
||||
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 {};
|
||||
80
node_modules/ts-jest/dist/transformers/hoist-jest.js
generated
vendored
Normal file
80
node_modules/ts-jest/dist/transformers/hoist-jest.js
generated
vendored
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spread = (this && this.__spread) || function () {
|
||||
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
|
||||
return ar;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var HOIST_METHODS = ['mock', 'unmock'];
|
||||
exports.name = 'hoisting-jest-mock';
|
||||
exports.version = 1;
|
||||
function factory(cs) {
|
||||
var logger = cs.logger.child({ namespace: 'ts-hoisting' });
|
||||
var ts = cs.compilerModule;
|
||||
function shouldHoistNode(node) {
|
||||
return (ts.isExpressionStatement(node) &&
|
||||
ts.isCallExpression(node.expression) &&
|
||||
ts.isPropertyAccessExpression(node.expression.expression) &&
|
||||
ts.isIdentifier(node.expression.expression.expression) &&
|
||||
node.expression.expression.expression.text === 'jest' &&
|
||||
ts.isIdentifier(node.expression.expression.name) &&
|
||||
HOIST_METHODS.includes(node.expression.expression.name.text));
|
||||
}
|
||||
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) {
|
||||
enter();
|
||||
var resultNode = ts.visitEachChild(node, visitor, ctx);
|
||||
if (hoisted[level] && hoisted[level].length) {
|
||||
var hoistedStmts_1 = hoisted[level];
|
||||
var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s); });
|
||||
var newNode = ts.getMutableClone(resultNode);
|
||||
newNode.statements = ts.createNodeArray(__spread(hoistedStmts_1, otherStmts));
|
||||
resultNode = newNode;
|
||||
}
|
||||
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 {};
|
||||
11
node_modules/ts-jest/dist/transformers/index.js
generated
vendored
Normal file
11
node_modules/ts-jest/dist/transformers/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
"use strict";
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||||
result["default"] = mod;
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var hoisting = __importStar(require("./hoist-jest"));
|
||||
exports.internals = [hoisting];
|
||||
17
node_modules/ts-jest/dist/ts-jest-transformer.d.ts
generated
vendored
Normal file
17
node_modules/ts-jest/dist/ts-jest-transformer.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
/// <reference types="jest" />
|
||||
import { Logger } from 'bs-logger';
|
||||
import { ConfigSet } from './config/config-set';
|
||||
import { TsJestGlobalOptions } from './types';
|
||||
export declare class TsJestTransformer implements jest.Transformer {
|
||||
static readonly lastTransformerId: number;
|
||||
readonly logger: Logger;
|
||||
readonly id: number;
|
||||
readonly options: TsJestGlobalOptions;
|
||||
constructor(baseOptions?: TsJestGlobalOptions);
|
||||
configsFor(jestConfig: jest.ProjectConfig | string): ConfigSet;
|
||||
process(input: string, filePath: jest.Path, jestConfig: jest.ProjectConfig, transformOptions?: jest.TransformOptions): jest.TransformedSource | string;
|
||||
getCacheKey(fileContent: string, filePath: string, jestConfigStr: string, transformOptions?: {
|
||||
instrument?: boolean;
|
||||
rootDir?: string;
|
||||
}): string;
|
||||
}
|
||||
132
node_modules/ts-jest/dist/ts-jest-transformer.js
generated
vendored
Normal file
132
node_modules/ts-jest/dist/ts-jest-transformer.js
generated
vendored
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
"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 });
|
||||
var util_1 = require("util");
|
||||
var config_set_1 = require("./config/config-set");
|
||||
var json_1 = require("./util/json");
|
||||
var jsonable_value_1 = require("./util/jsonable-value");
|
||||
var logger_1 = require("./util/logger");
|
||||
var messages_1 = require("./util/messages");
|
||||
var sha1_1 = require("./util/sha1");
|
||||
exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
|
||||
var TsJestTransformer = (function () {
|
||||
function TsJestTransformer(baseOptions) {
|
||||
if (baseOptions === void 0) { baseOptions = {}; }
|
||||
this.options = __assign({}, baseOptions);
|
||||
this.id = TsJestTransformer._nextTransformerId;
|
||||
this.logger = logger_1.rootLogger.child({
|
||||
transformerId: this.id,
|
||||
namespace: 'jest-transformer',
|
||||
});
|
||||
this.logger.debug({ baseOptions: baseOptions }, 'created new transformer');
|
||||
}
|
||||
Object.defineProperty(TsJestTransformer, "lastTransformerId", {
|
||||
get: function () {
|
||||
return TsJestTransformer._lastTransformerId;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(TsJestTransformer, "_nextTransformerId", {
|
||||
get: function () {
|
||||
return ++TsJestTransformer._lastTransformerId;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
});
|
||||
TsJestTransformer.prototype[exports.INSPECT_CUSTOM] = function () {
|
||||
return "[object TsJestTransformer<#" + this.id + ">]";
|
||||
};
|
||||
TsJestTransformer.prototype.configsFor = function (jestConfig) {
|
||||
var csi;
|
||||
var jestConfigObj;
|
||||
if (typeof jestConfig === 'string') {
|
||||
csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.serialized === jestConfig; });
|
||||
if (csi)
|
||||
return csi.configSet;
|
||||
jestConfigObj = json_1.parse(jestConfig);
|
||||
}
|
||||
else {
|
||||
csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.value === jestConfig; });
|
||||
if (csi)
|
||||
return csi.configSet;
|
||||
var serialized_1 = json_1.stringify(jestConfig);
|
||||
csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.serialized === serialized_1; });
|
||||
if (csi) {
|
||||
csi.jestConfig.value = jestConfig;
|
||||
return csi.configSet;
|
||||
}
|
||||
jestConfigObj = jestConfig;
|
||||
}
|
||||
this.logger.info("no matching config-set found, creating a new one");
|
||||
var configSet = new config_set_1.ConfigSet(jestConfigObj, this.options, this.logger);
|
||||
TsJestTransformer._configSetsIndex.push({
|
||||
jestConfig: new jsonable_value_1.JsonableValue(jestConfigObj),
|
||||
configSet: configSet,
|
||||
});
|
||||
return configSet;
|
||||
};
|
||||
TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
|
||||
this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'processing', filePath);
|
||||
var result;
|
||||
var source = input;
|
||||
var configs = this.configsFor(jestConfig);
|
||||
var hooks = configs.hooks;
|
||||
var stringify = configs.shouldStringifyContent(filePath);
|
||||
var babelJest = stringify ? undefined : configs.babelJestTransformer;
|
||||
var isDefinitionFile = filePath.endsWith('.d.ts');
|
||||
var isJsFile = !isDefinitionFile && /\.jsx?$/.test(filePath);
|
||||
var isTsFile = isDefinitionFile || /\.tsx?$/.test(filePath);
|
||||
if (stringify) {
|
||||
result = "module.exports=" + JSON.stringify(source);
|
||||
}
|
||||
else if (isDefinitionFile) {
|
||||
result = '';
|
||||
}
|
||||
else if (!configs.typescript.options.allowJs && isJsFile) {
|
||||
this.logger.warn({ fileName: filePath }, messages_1.interpolate(messages_1.Errors.GotJsFileButAllowJsFalse, { path: filePath }));
|
||||
result = source;
|
||||
}
|
||||
else if (isJsFile || isTsFile) {
|
||||
result = configs.tsCompiler.compile(source, filePath);
|
||||
}
|
||||
else {
|
||||
var message = babelJest ? messages_1.Errors.GotUnknownFileTypeWithBabel : messages_1.Errors.GotUnknownFileTypeWithoutBabel;
|
||||
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({}, 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) {
|
||||
if (transformOptions === void 0) { transformOptions = {}; }
|
||||
this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
|
||||
var configs = this.configsFor(jestConfigStr);
|
||||
var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? configs.rootDir : _b;
|
||||
return sha1_1.sha1(configs.cacheKey, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
|
||||
};
|
||||
TsJestTransformer._configSetsIndex = [];
|
||||
TsJestTransformer._lastTransformerId = 0;
|
||||
return TsJestTransformer;
|
||||
}());
|
||||
exports.TsJestTransformer = TsJestTransformer;
|
||||
112
node_modules/ts-jest/dist/types.d.ts
generated
vendored
Normal file
112
node_modules/ts-jest/dist/types.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
/// <reference types="jest" />
|
||||
import * as _babel from 'babel__core';
|
||||
import _ts, { CompilerOptions, SourceFile, TransformerFactory } from 'typescript';
|
||||
import { ConfigSet } from './config/config-set';
|
||||
export declare type TBabelCore = typeof _babel;
|
||||
export declare type TTypeScript = typeof _ts;
|
||||
export declare type TBabelJest = Required<jest.Transformer>;
|
||||
export declare type BabelJestTransformer = {
|
||||
[K in Exclude<keyof jest.Transformer, 'createTransformer'>]: Exclude<jest.Transformer[K], undefined>;
|
||||
};
|
||||
export declare type BabelConfig = _babel.TransformOptions;
|
||||
export interface TsJestGlobalOptions {
|
||||
tsConfig?: boolean | string | CompilerOptions;
|
||||
packageJson?: boolean | string | object;
|
||||
isolatedModules?: boolean;
|
||||
compiler?: string;
|
||||
astTransformers?: string[];
|
||||
diagnostics?: boolean | {
|
||||
pretty?: boolean;
|
||||
ignoreCodes?: number | string | Array<number | string>;
|
||||
pathRegex?: RegExp | string;
|
||||
warnOnly?: boolean;
|
||||
};
|
||||
babelConfig?: boolean | string | BabelConfig;
|
||||
stringifyContentPathRegex?: string | RegExp;
|
||||
}
|
||||
interface TsJestConfig$tsConfig$file {
|
||||
kind: 'file';
|
||||
value: string | undefined;
|
||||
}
|
||||
interface TsJestConfig$tsConfig$inline {
|
||||
kind: 'inline';
|
||||
value: CompilerOptions;
|
||||
}
|
||||
declare type TsJestConfig$tsConfig = TsJestConfig$tsConfig$file | TsJestConfig$tsConfig$inline | undefined;
|
||||
interface TsJestConfig$diagnostics {
|
||||
pretty: boolean;
|
||||
ignoreCodes: number[];
|
||||
pathRegex?: string | undefined;
|
||||
throws: boolean;
|
||||
}
|
||||
interface TsJestConfig$babelConfig$file {
|
||||
kind: 'file';
|
||||
value: string | undefined;
|
||||
}
|
||||
interface TsJestConfig$babelConfig$inline {
|
||||
kind: 'inline';
|
||||
value: BabelConfig;
|
||||
}
|
||||
declare type TsJestConfig$babelConfig = TsJestConfig$babelConfig$file | TsJestConfig$babelConfig$inline | undefined;
|
||||
interface TsJestConfig$packageJson$file {
|
||||
kind: 'file';
|
||||
value: string | undefined;
|
||||
}
|
||||
interface TsJestConfig$packageJson$inline {
|
||||
kind: 'inline';
|
||||
value: any;
|
||||
}
|
||||
declare type TsJestConfig$packageJson = TsJestConfig$packageJson$file | TsJestConfig$packageJson$inline | undefined;
|
||||
declare type TsJestConfig$stringifyContentPathRegex = string | undefined;
|
||||
export interface TsJestConfig {
|
||||
tsConfig: TsJestConfig$tsConfig;
|
||||
packageJson: TsJestConfig$packageJson;
|
||||
isolatedModules: boolean;
|
||||
compiler: string;
|
||||
diagnostics: TsJestConfig$diagnostics;
|
||||
babelConfig: TsJestConfig$babelConfig;
|
||||
transformers: string[];
|
||||
stringifyContentPathRegex: TsJestConfig$stringifyContentPathRegex;
|
||||
}
|
||||
export interface TsJestHooksMap {
|
||||
afterProcess?(args: any[], result: string | jest.TransformedSource): string | jest.TransformedSource | void;
|
||||
}
|
||||
export interface TSCommon {
|
||||
version: typeof _ts.version;
|
||||
sys: typeof _ts.sys;
|
||||
ScriptSnapshot: typeof _ts.ScriptSnapshot;
|
||||
displayPartsToString: typeof _ts.displayPartsToString;
|
||||
createLanguageService: typeof _ts.createLanguageService;
|
||||
getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
|
||||
getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
|
||||
flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
|
||||
transpileModule: typeof _ts.transpileModule;
|
||||
ModuleKind: typeof _ts.ModuleKind;
|
||||
ScriptTarget: typeof _ts.ScriptTarget;
|
||||
findConfigFile: typeof _ts.findConfigFile;
|
||||
readConfigFile: typeof _ts.readConfigFile;
|
||||
parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
|
||||
formatDiagnostics: typeof _ts.formatDiagnostics;
|
||||
formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
|
||||
}
|
||||
export interface TypeInfo {
|
||||
name: string;
|
||||
comment: string;
|
||||
}
|
||||
export interface TsCompiler {
|
||||
cwd: string;
|
||||
extensions: string[];
|
||||
cachedir: string | undefined;
|
||||
ts: TSCommon;
|
||||
compile(code: string, fileName: string, lineOffset?: number): string;
|
||||
getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
|
||||
}
|
||||
export interface AstTransformerDesc {
|
||||
name: string;
|
||||
version: number;
|
||||
factory(cs: ConfigSet): TransformerFactory<SourceFile>;
|
||||
}
|
||||
export interface IPackageJson {
|
||||
main: string;
|
||||
}
|
||||
export {};
|
||||
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/util/backports.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/backports.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
101
node_modules/ts-jest/dist/util/backports.js
generated
vendored
Normal file
101
node_modules/ts-jest/dist/util/backports.js
generated
vendored
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
"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 });
|
||||
var _a;
|
||||
var bs_logger_1 = require("bs-logger");
|
||||
var messages_1 = require("./messages");
|
||||
var context = (_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'backports', _a);
|
||||
exports.backportJestConfig = function (logger, config) {
|
||||
logger.debug(__assign({}, context, { config: config }), 'backporting config');
|
||||
var _a = (config || {}).globals, globals = _a === void 0 ? {} : _a;
|
||||
var _b = globals["ts-jest"], tsJest = _b === void 0 ? {} : _b;
|
||||
var mergeTsJest = {};
|
||||
var hadWarnings = false;
|
||||
var warnConfig = function (oldPath, newPath, note) {
|
||||
hadWarnings = true;
|
||||
logger.warn(context, messages_1.interpolate(note ? messages_1.Deprecateds.ConfigOptionWithNote : messages_1.Deprecateds.ConfigOption, {
|
||||
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', messages_1.Deprecateds.ConfigOptionUseBabelRcNote);
|
||||
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, messages_1.Helps.MigrateConfigUsingCLI);
|
||||
}
|
||||
return __assign({}, config, { globals: __assign({}, globals, { 'ts-jest': __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(messages_1.Deprecateds.EnvVar, {
|
||||
old: 'TS_JEST_DEBUG',
|
||||
new: 'TS_JEST_LOG',
|
||||
}));
|
||||
}
|
||||
};
|
||||
3
node_modules/ts-jest/dist/util/exported.d.ts
generated
vendored
Normal file
3
node_modules/ts-jest/dist/util/exported.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
export { mocked } from './testing';
|
||||
export { createJestPreset } from '../config/create-jest-preset';
|
||||
export { pathsToModuleNameMapper } from '../config/paths-to-module-name-mapper';
|
||||
8
node_modules/ts-jest/dist/util/exported.js
generated
vendored
Normal file
8
node_modules/ts-jest/dist/util/exported.js
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var testing_1 = require("./testing");
|
||||
exports.mocked = testing_1.mocked;
|
||||
var create_jest_preset_1 = require("../config/create-jest-preset");
|
||||
exports.createJestPreset = create_jest_preset_1.createJestPreset;
|
||||
var paths_to_module_name_mapper_1 = require("../config/paths-to-module-name-mapper");
|
||||
exports.pathsToModuleNameMapper = paths_to_module_name_mapper_1.pathsToModuleNameMapper;
|
||||
1
node_modules/ts-jest/dist/util/get-package-version.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/get-package-version.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
10
node_modules/ts-jest/dist/util/get-package-version.js
generated
vendored
Normal file
10
node_modules/ts-jest/dist/util/get-package-version.js
generated
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
function getPackageVersion(moduleName) {
|
||||
try {
|
||||
return require(moduleName + "/package.json").version;
|
||||
}
|
||||
catch (err) { }
|
||||
return;
|
||||
}
|
||||
exports.getPackageVersion = getPackageVersion;
|
||||
1
node_modules/ts-jest/dist/util/importer.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/importer.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
193
node_modules/ts-jest/dist/util/importer.js
generated
vendored
Normal file
193
node_modules/ts-jest/dist/util/importer.js
generated
vendored
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
"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 });
|
||||
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: true,
|
||||
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(messages_1.Errors.LoadingModuleFailed, { module: res.given, error: res.error.message }));
|
||||
}
|
||||
var msg = alternatives.length ? messages_1.Errors.UnableToLoadAnyModule : messages_1.Errors.UnableToLoadOneModule;
|
||||
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(messages_1.Helps.FixMissingModule, 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(moduleName);
|
||||
}
|
||||
catch (error) {
|
||||
result.error = error;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
var requireModule = function (mod) { return require(mod); };
|
||||
var resolveModule = function (mod) { return require.resolve(mod); };
|
||||
function __requireModule(localRequire, localResolve) {
|
||||
requireModule = localRequire;
|
||||
resolveModule = localResolve;
|
||||
}
|
||||
exports.__requireModule = __requireModule;
|
||||
1
node_modules/ts-jest/dist/util/json.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/json.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
31
node_modules/ts-jest/dist/util/json.js
generated
vendored
Normal file
31
node_modules/ts-jest/dist/util/json.js
generated
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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 = {}));
|
||||
1
node_modules/ts-jest/dist/util/jsonable-value.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/jsonable-value.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
34
node_modules/ts-jest/dist/util/jsonable-value.js
generated
vendored
Normal file
34
node_modules/ts-jest/dist/util/jsonable-value.js
generated
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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: true,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(JsonableValue.prototype, "serialized", {
|
||||
get: function () {
|
||||
return this._serialized;
|
||||
},
|
||||
enumerable: true,
|
||||
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/util/logger.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/logger.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
21
node_modules/ts-jest/dist/util/logger.js
generated
vendored
Normal file
21
node_modules/ts-jest/dist/util/logger.js
generated
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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/util/memoize.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/memoize.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
47
node_modules/ts-jest/dist/util/memoize.js
generated
vendored
Normal file
47
node_modules/ts-jest/dist/util/memoize.js
generated
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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/util/messages.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/messages.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
47
node_modules/ts-jest/dist/util/messages.js
generated
vendored
Normal file
47
node_modules/ts-jest/dist/util/messages.js
generated
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var Errors;
|
||||
(function (Errors) {
|
||||
Errors["LoadingModuleFailed"] = "Loading module {{module}} failed with error: {{error}}";
|
||||
Errors["UnableToLoadOneModule"] = "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
|
||||
Errors["UnableToLoadAnyModule"] = "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}";
|
||||
Errors["TypesUnavailableWithoutTypeCheck"] = "Type information is unavailable with \"isolatedModules\"";
|
||||
Errors["UnableToRequireDefinitionFile"] = "Unable to require `.d.ts` 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}}`.";
|
||||
Errors["FileNotFound"] = "File not found: {{inputPath}} (resolved as: {{resolvedPath}})";
|
||||
Errors["UntestedDependencyVersion"] = "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.";
|
||||
Errors["MissingDependency"] = "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}}).";
|
||||
Errors["UnableToCompileTypeScript"] = "TypeScript diagnostics ({{help}}):\n{{diagnostics}}";
|
||||
Errors["NotMappingMultiStarPath"] = "Not mapping \"{{path}}\" because it has more than one star (`*`).";
|
||||
Errors["NotMappingPathWithEmptyMap"] = "Not mapping \"{{path}}\" because it has no target.";
|
||||
Errors["MappingOnlyFirstTargetOfPath"] = "Mapping only to first target of \"{{path}}\" because it has more than one ({{count}}).";
|
||||
Errors["GotJsFileButAllowJsFalse"] = "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";
|
||||
Errors["GotUnknownFileTypeWithoutBabel"] = "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.";
|
||||
Errors["GotUnknownFileTypeWithBabel"] = "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.";
|
||||
Errors["ConfigNoModuleInterop"] = "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.";
|
||||
Errors["UnableToFindProjectRoot"] = "Unable to find the root of the project where ts-jest has been installed.";
|
||||
Errors["UnableToResolveJestConfig"] = "Unable to resolve jest-config. Ensure Jest is properly installed.";
|
||||
})(Errors = exports.Errors || (exports.Errors = {}));
|
||||
var Helps;
|
||||
(function (Helps) {
|
||||
Helps["FixMissingModule"] = "{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)";
|
||||
Helps["IgnoreDiagnosticCode"] = "customize using `[jest-config].globals.ts-jest.diagnostics` option";
|
||||
Helps["MigrateConfigUsingCLI"] = "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.";
|
||||
})(Helps = exports.Helps || (exports.Helps = {}));
|
||||
var Deprecateds;
|
||||
(function (Deprecateds) {
|
||||
Deprecateds["EnvVar"] = "Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead.";
|
||||
Deprecateds["ConfigOption"] = "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.";
|
||||
Deprecateds["ConfigOptionWithNote"] = "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n \u21B3 {{note}}";
|
||||
Deprecateds["ConfigOptionUseBabelRcNote"] = "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845";
|
||||
Deprecateds["HelperMovedToUtils"] = "The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.";
|
||||
})(Deprecateds = exports.Deprecateds || (exports.Deprecateds = {}));
|
||||
var ImportReasons;
|
||||
(function (ImportReasons) {
|
||||
ImportReasons["TsJest"] = "Using \"ts-jest\" requires this package to be installed.";
|
||||
ImportReasons["BabelJest"] = "Using \"babel-jest\" requires this package to be installed.";
|
||||
})(ImportReasons = exports.ImportReasons || (exports.ImportReasons = {}));
|
||||
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/util/normalize-slashes.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/normalize-slashes.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
6
node_modules/ts-jest/dist/util/normalize-slashes.js
generated
vendored
Normal file
6
node_modules/ts-jest/dist/util/normalize-slashes.js
generated
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
function normalizeSlashes(value) {
|
||||
return value.replace(/\\/g, '/');
|
||||
}
|
||||
exports.normalizeSlashes = normalizeSlashes;
|
||||
1
node_modules/ts-jest/dist/util/sha1.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/sha1.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
31
node_modules/ts-jest/dist/util/sha1.js
generated
vendored
Normal file
31
node_modules/ts-jest/dist/util/sha1.js
generated
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
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;
|
||||
34
node_modules/ts-jest/dist/util/testing.d.ts
generated
vendored
Normal file
34
node_modules/ts-jest/dist/util/testing.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/// <reference types="jest" />
|
||||
declare type MockableFunction = (...args: any[]) => any;
|
||||
declare type MethodKeysOf<T> = {
|
||||
[K in keyof T]: T[K] extends MockableFunction ? K : never;
|
||||
}[keyof T];
|
||||
declare type PropertyKeysOf<T> = {
|
||||
[K in keyof T]: T[K] extends MockableFunction ? never : K;
|
||||
}[keyof T];
|
||||
declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
|
||||
declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
|
||||
interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
|
||||
new (...args: ConstructorArgumentsOf<T>): T;
|
||||
(...args: ArgumentsOf<T>): ReturnType<T>;
|
||||
}
|
||||
declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : {};
|
||||
declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
|
||||
[K in keyof T]: T[K];
|
||||
};
|
||||
declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
|
||||
declare type MockedObject<T> = MaybeMockedConstructor<T> & {
|
||||
[K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
|
||||
} & {
|
||||
[K in PropertyKeysOf<T>]: T[K];
|
||||
};
|
||||
declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
|
||||
[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>;
|
||||
export {};
|
||||
7
node_modules/ts-jest/dist/util/testing.js
generated
vendored
Normal file
7
node_modules/ts-jest/dist/util/testing.js
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
function mocked(item, _deep) {
|
||||
if (_deep === void 0) { _deep = false; }
|
||||
return item;
|
||||
}
|
||||
exports.mocked = mocked;
|
||||
1
node_modules/ts-jest/dist/util/ts-error.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/ts-error.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
41
node_modules/ts-jest/dist/util/ts-error.js
generated
vendored
Normal file
41
node_modules/ts-jest/dist/util/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 (b.hasOwnProperty(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 });
|
||||
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(messages_1.Errors.UnableToCompileTypeScript, {
|
||||
diagnostics: diagnosticText.trim(),
|
||||
help: messages_1.Helps.IgnoreDiagnosticCode,
|
||||
})) || 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/util/version-checkers.d.ts
generated
vendored
Normal file
1
node_modules/ts-jest/dist/util/version-checkers.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
export {};
|
||||
63
node_modules/ts-jest/dist/util/version-checkers.js
generated
vendored
Normal file
63
node_modules/ts-jest/dist/util/version-checkers.js
generated
vendored
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var semver_1 = require("semver");
|
||||
var get_package_version_1 = require("./get-package-version");
|
||||
var logger_1 = require("./logger");
|
||||
var messages_1 = require("./messages");
|
||||
var logger = logger_1.rootLogger.child({ namespace: 'versions' });
|
||||
var ExpectedVersions;
|
||||
(function (ExpectedVersions) {
|
||||
ExpectedVersions["Jest"] = ">=24 <25";
|
||||
ExpectedVersions["TypeScript"] = ">=2.7 <4";
|
||||
ExpectedVersions["BabelJest"] = ">=24 <25";
|
||||
ExpectedVersions["BabelCore"] = ">=7.0.0-beta.0 <8";
|
||||
})(ExpectedVersions = exports.ExpectedVersions || (exports.ExpectedVersions = {}));
|
||||
exports.VersionCheckers = {
|
||||
jest: createVersionChecker('jest', ExpectedVersions.Jest),
|
||||
typescript: createVersionChecker('typescript', ExpectedVersions.TypeScript),
|
||||
babelJest: createVersionChecker('babel-jest', ExpectedVersions.BabelJest),
|
||||
babelCore: createVersionChecker('@babel/core', ExpectedVersions.BabelCore),
|
||||
};
|
||||
function checkVersion(name, expectedRange, action) {
|
||||
if (action === void 0) { action = 'warn'; }
|
||||
var version = get_package_version_1.getPackageVersion(name);
|
||||
var success = !!version && semver_1.satisfies(version, expectedRange);
|
||||
logger.debug({
|
||||
actualVersion: version,
|
||||
expectedVersion: expectedRange,
|
||||
}, 'checking version of %s: %s', name, success ? 'OK' : 'NOT OK');
|
||||
if (!action || success)
|
||||
return success;
|
||||
var message = messages_1.interpolate(version ? messages_1.Errors.UntestedDependencyVersion : messages_1.Errors.MissingDependency, {
|
||||
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