Add node modules and new code for release (#39)

Co-authored-by: tbarnes94 <tbarnes94@users.noreply.github.com>

node_modules/ts-jest/dist/compiler/compiler-utils.d.ts

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

node_modules/ts-jest/dist/compiler/compiler-utils.js

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

node_modules/ts-jest/dist/compiler/instance.d.ts

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

node_modules/ts-jest/dist/compiler/instance.js

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

node_modules/ts-jest/dist/compiler/language-service.d.ts

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

node_modules/ts-jest/dist/compiler/language-service.js

@@ -0,0 +1,155 @@
+"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 path_1 = require("path");
+var constants_1 = require("../constants");
+var messages_1 = require("../util/messages");
+var compiler_utils_1 = require("./compiler-utils");
+var memoize = require("lodash.memoize");
+function doTypeChecking(configs, fileName, service, logger) {
+    if (configs.shouldReportDiagnostic(fileName)) {
+        var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
+        configs.raiseDiagnostics(diagnostics, fileName, logger);
+    }
+}
+exports.initializeLanguageServiceInstance = function (configs, memoryCache, logger) {
+    var _a;
+    logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
+    var ts = configs.compilerModule;
+    var cwd = configs.cwd;
+    var cacheDir = configs.tsCacheDir;
+    var _b = configs.parsedTsConfig, options = _b.options, fileNames = _b.fileNames;
+    var serviceHostTraceCtx = (_a = {
+            namespace: 'ts:serviceHost',
+            call: null
+        },
+        _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
+        _a);
+    function isFileInCache(fileName) {
+        return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
+    }
+    var projectVersion = 1;
+    var updateMemoryCache = function (contents, fileName) {
+        logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
+        var shouldIncrementProjectVersion = false;
+        var hit = isFileInCache(fileName);
+        if (!hit) {
+            memoryCache.files.set(fileName, {
+                text: contents,
+                version: 1,
+            });
+            shouldIncrementProjectVersion = true;
+        }
+        else {
+            var previousContents = memoryCache.files.get(fileName).text;
+            if (previousContents !== contents) {
+                memoryCache.files.set(fileName, {
+                    text: contents,
+                    version: memoryCache.files.get(fileName).version + 1,
+                });
+                if (hit)
+                    shouldIncrementProjectVersion = true;
+            }
+            if (!fileNames.includes(fileName)) {
+                shouldIncrementProjectVersion = true;
+            }
+        }
+        if (shouldIncrementProjectVersion)
+            projectVersion++;
+    };
+    var serviceHost = {
+        getProjectVersion: function () { return String(projectVersion); },
+        getScriptFileNames: function () { return __spread(memoryCache.files.keys()); },
+        getScriptVersion: function (fileName) {
+            var normalizedFileName = path_1.normalize(fileName);
+            var version = memoryCache.files.get(normalizedFileName).version;
+            return version === undefined ? undefined : String(version);
+        },
+        getScriptSnapshot: function (fileName) {
+            var _a;
+            var normalizedFileName = path_1.normalize(fileName);
+            var hit = memoryCache.files.has(normalizedFileName) && memoryCache.files.get(normalizedFileName).version !== 0;
+            logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
+            if (!hit) {
+                memoryCache.files.set(normalizedFileName, {
+                    text: ts.sys.readFile(normalizedFileName),
+                    version: 1,
+                });
+            }
+            var contents = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.text;
+            if (contents === undefined)
+                return;
+            return ts.ScriptSnapshot.fromString(contents);
+        },
+        fileExists: memoize(ts.sys.fileExists),
+        readFile: logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile)),
+        readDirectory: memoize(ts.sys.readDirectory),
+        getDirectories: memoize(ts.sys.getDirectories),
+        directoryExists: memoize(ts.sys.directoryExists),
+        realpath: memoize(ts.sys.realpath),
+        getNewLine: function () { return constants_1.LINE_FEED; },
+        getCurrentDirectory: function () { return cwd; },
+        getCompilationSettings: function () { return options; },
+        getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); },
+        getCustomTransformers: function () { return configs.tsCustomTransformers; },
+    };
+    logger.debug('initializeLanguageServiceInstance(): creating language service');
+    var service = ts.createLanguageService(serviceHost, ts.createDocumentRegistry());
+    return {
+        compileFn: function (code, fileName) {
+            logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
+            updateMemoryCache(code, fileName);
+            var output = service.getEmitOutput(fileName);
+            logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
+            doTypeChecking(configs, fileName, service, logger);
+            if (cacheDir) {
+                if (compiler_utils_1.isTestFile(configs.testMatchPatterns, fileName)) {
+                    compiler_utils_1.cacheResolvedModules(fileName, code, memoryCache, service.getProgram(), cacheDir, logger);
+                }
+                else {
+                    Object.entries(memoryCache.resolvedModules)
+                        .filter(function (entry) {
+                        return entry[1].modulePaths.find(function (modulePath) { return modulePath === fileName; }) && !memoryCache.files.has(entry[0]);
+                    })
+                        .forEach(function (entry) {
+                        var testFileName = entry[0];
+                        var testFileContent = entry[1].testFileContent;
+                        logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics for test file that imports this module using language service');
+                        updateMemoryCache(testFileContent, testFileName);
+                        doTypeChecking(configs, testFileName, service, logger);
+                    });
+                }
+            }
+            if (output.emitSkipped) {
+                throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
+            }
+            if (!output.outputFiles.length) {
+                throw new TypeError(messages_1.interpolate("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`.", {
+                    file: path_1.basename(fileName),
+                }));
+            }
+            return [output.outputFiles[1].text, output.outputFiles[0].text];
+        },
+        program: service.getProgram(),
+    };
+};

node_modules/ts-jest/dist/compiler/transpiler.d.ts

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

node_modules/ts-jest/dist/compiler/transpiler.js

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