Viewing File: /home/ubuntu/efiexchange-node-base/node_modules/ts-node-dev/lib/compiler.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeCompiler = void 0;
var tsNode = __importStar(require("ts-node"));
var fs_1 = __importDefault(require("fs"));
var path_1 = __importDefault(require("path"));
var os_1 = __importDefault(require("os"));
var mkdirp_1 = __importDefault(require("mkdirp"));
var rimraf_1 = __importDefault(require("rimraf"));
var tsconfig_1 = require("tsconfig");
var get_compiled_path_1 = require("./get-compiled-path");
var get_cwd_1 = require("./get-cwd");
var fixPath = function (p) { return p.replace(/\\/g, '/').replace(/\$/g, '$$$$'); };
var sourceMapSupportPath = require.resolve('source-map-support');
var compileExtensions = ['.ts', '.tsx'];
var cwd = process.cwd();
var compilationInstanceStamp = Math.random().toString().slice(2);
var originalJsHandler = require.extensions['.js'];
exports.makeCompiler = function (options, _a) {
    var log = _a.log, restart = _a.restart;
    var _errorCompileTimeout;
    var allowJs = false;
    var project = options['project'];
    var tsConfigPath = tsconfig_1.resolveSync(cwd, typeof project === 'string' ? project : undefined) || '';
    var compiledPathsHash = {};
    var tmpDir = options['cache-directory']
        ? path_1.default.resolve(options['cache-directory'])
        : fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), '.ts-node'));
    var writeChildHookFile = function (options) {
        var compileTimeout = parseInt(options['compile-timeout']);
        var getIgnoreVal = function (ignore) {
            var ignoreVal = !ignore || ignore === 'false'
                ? 'false'
                : '[' +
                    ignore
                        .split(/,/)
                        .map(function (i) { return i.trim(); })
                        .map(function (ignore) { return 'new RegExp("' + ignore + '")'; })
                        .join(', ') +
                    ']';
            return ignoreVal;
        };
        var varDecl = function (name, value) { return "var " + name + " = '" + value + "'"; };
        var replacements = [
            compileTimeout ? ['10000', compileTimeout.toString()] : null,
            allowJs ? ['allowJs = false', 'allowJs = true'] : null,
            options['prefer-ts-exts']
                ? ['preferTs = false', 'preferTs = true']
                : null,
            options['exec-check'] ? ['execCheck = false', 'execCheck = true'] : null,
            options['exit-child'] ? ['exitChild = false', 'exitChild = true'] : null,
            options['ignore'] !== undefined
                ? [
                    'var ignore = [/node_modules/]',
                    'var ignore = ' + getIgnoreVal(options['ignore']),
                ]
                : null,
            [
                varDecl('compilationId', ''),
                varDecl('compilationId', getCompilationId()),
            ],
            [varDecl('compiledDir', ''), varDecl('compiledDir', getCompiledDir())],
            [
                './get-compiled-path',
                fixPath(path_1.default.join(__dirname, 'get-compiled-path')),
            ],
            [
                varDecl('readyFile', ''),
                varDecl('readyFile', getCompilerReadyFilePath()),
            ],
            [
                varDecl('sourceMapSupportPath', ''),
                varDecl('sourceMapSupportPath', fixPath(sourceMapSupportPath)),
            ],
            [
                varDecl('libPath', ''),
                varDecl('libPath', __dirname.replace(/\\/g, '\\\\')),
            ],
            ['__dirname', '"' + fixPath(__dirname) + '"'],
        ]
            .filter(function (_) { return !!_; })
            .map(function (_) { return _; });
        var fileText = fs_1.default.readFileSync(path_1.default.join(__dirname, 'child-require-hook.js'), 'utf-8');
        var fileData = replacements.reduce(function (text, _a) {
            var what = _a[0], to = _a[1];
            return text.replace(what, to);
        }, fileText);
        fs_1.default.writeFileSync(getChildHookPath(), fileData);
    };
    var init = function () {
        registerTsNode();
        /* clean up compiled on each new init*/
        rimraf_1.default.sync(getCompiledDir());
        createCompiledDir();
        // check if `allowJs` compiler option enable
        // (.js handler was changed while ts-node registration)
        allowJs = require.extensions['.js'] !== originalJsHandler;
        if (allowJs) {
            compileExtensions.push('.js', '.jsx');
        }
        writeChildHookFile(options);
    };
    var getCompilationId = function () {
        return compilationInstanceStamp;
    };
    var createCompiledDir = function () {
        var compiledDir = getCompiledDir();
        if (!fs_1.default.existsSync(compiledDir)) {
            mkdirp_1.default.sync(getCompiledDir());
        }
    };
    var getCompiledDir = function () {
        return path_1.default.join(tmpDir, 'compiled').replace(/\\/g, '/');
    };
    var getCompileReqFilePath = function () {
        return path_1.default.join(getCompiledDir(), getCompilationId() + '.req');
    };
    var getCompilerReadyFilePath = function () {
        return path_1.default
            .join(os_1.default.tmpdir(), 'ts-node-dev-ready-' + compilationInstanceStamp)
            .replace(/\\/g, '/');
    };
    var getChildHookPath = function () {
        return path_1.default
            .join(os_1.default.tmpdir(), 'ts-node-dev-hook-' + compilationInstanceStamp + '.js')
            .replace(/\\/g, '/');
    };
    var writeReadyFile = function () {
        fs_1.default.writeFileSync(getCompilerReadyFilePath(), '');
    };
    var clearErrorCompile = function () {
        clearTimeout(_errorCompileTimeout);
    };
    var registerTsNode = function () {
        Object.keys(compiledPathsHash).forEach(function (key) {
            delete compiledPathsHash[key];
        });
        ['.js', '.jsx', '.ts', '.tsx'].forEach(function (ext) {
            require.extensions[ext] = originalJsHandler;
        });
        var scriptPath = options._.length
            ? path_1.default.resolve(cwd, options._[0])
            : undefined;
        var DEFAULTS = tsNode.DEFAULTS;
        tsNode.register({
            // --dir does not work (it gives a boolean only) so we only check for script-mode
            dir: get_cwd_1.getCwd(options['dir'], options['script-mode'], scriptPath),
            scope: options['scope'] || DEFAULTS.scope,
            emit: options['emit'] || DEFAULTS.emit,
            files: options['files'] || DEFAULTS.files,
            pretty: options['pretty'] || DEFAULTS.pretty,
            transpileOnly: options['transpile-only'] || DEFAULTS.transpileOnly,
            ignore: options['ignore']
                ? tsNode.split(options['ignore'])
                : DEFAULTS.ignore,
            preferTsExts: options['prefer-ts-exts'] || DEFAULTS.preferTsExts,
            logError: options['log-error'] || DEFAULTS.logError,
            project: options['project'],
            skipProject: options['skip-project'],
            skipIgnore: options['skip-ignore'],
            compiler: options['compiler'] || DEFAULTS.compiler,
            compilerHost: options['compiler-host'] || DEFAULTS.compilerHost,
            ignoreDiagnostics: options['ignore-diagnostics']
                ? tsNode.split(options['ignore-diagnostics'])
                : DEFAULTS.ignoreDiagnostics,
            compilerOptions: tsNode.parse(options['compiler-options']),
        });
    };
    var compiler = {
        tsConfigPath: tsConfigPath,
        init: init,
        getCompileReqFilePath: getCompileReqFilePath,
        getChildHookPath: getChildHookPath,
        writeReadyFile: writeReadyFile,
        clearErrorCompile: clearErrorCompile,
        compileChanged: function (fileName) {
            var ext = path_1.default.extname(fileName);
            if (compileExtensions.indexOf(ext) < 0)
                return;
            try {
                var code = fs_1.default.readFileSync(fileName, 'utf-8');
                compiler.compile({
                    code: code,
                    compile: fileName,
                    compiledPath: get_compiled_path_1.getCompiledPath(code, fileName, getCompiledDir()),
                });
            }
            catch (e) {
                console.error(e);
            }
        },
        compile: function (params) {
            var fileName = params.compile;
            var code = fs_1.default.readFileSync(fileName, 'utf-8');
            var compiledPath = params.compiledPath;
            // Prevent occasional duplicate compilation requests
            if (compiledPathsHash[compiledPath]) {
                return;
            }
            compiledPathsHash[compiledPath] = true;
            function writeCompiled(code, fileName) {
                fs_1.default.writeFile(compiledPath, code, function (err) {
                    err && log.error(err);
                    fs_1.default.writeFile(compiledPath + '.done', '', function (err) {
                        err && log.error(err);
                    });
                });
            }
            if (fs_1.default.existsSync(compiledPath)) {
                return;
            }
            var starTime = new Date().getTime();
            var m = {
                _compile: writeCompiled,
            };
            var _compile = function () {
                var ext = path_1.default.extname(fileName);
                var extHandler = require.extensions[ext];
                extHandler(m, fileName);
                log.debug(fileName, 'compiled in', new Date().getTime() - starTime, 'ms');
            };
            try {
                _compile();
            }
            catch (e) {
                console.error('Compilation error in', fileName);
                var errorCode = 'throw ' + 'new Error(' + JSON.stringify(e.message) + ')' + ';';
                writeCompiled(errorCode);
                // reinitialize ts-node compilation to clean up state after error
                // without timeout in causes cases error not be printed out
                setTimeout(function () {
                    registerTsNode();
                }, 0);
                if (!options['error-recompile']) {
                    return;
                }
                var timeoutMs_1 = parseInt(process.env.TS_NODE_DEV_ERROR_RECOMPILE_TIMEOUT || '0') ||
                    5000;
                var errorHandler_1 = function () {
                    clearTimeout(_errorCompileTimeout);
                    _errorCompileTimeout = setTimeout(function () {
                        try {
                            _compile();
                            restart(fileName);
                        }
                        catch (e) {
                            registerTsNode();
                            errorHandler_1();
                        }
                    }, timeoutMs_1);
                };
                errorHandler_1();
            }
        },
    };
    return compiler;
};