Initial commit of files
This commit is contained in:
286
node_modules/ts-node-dev/lib/index.js
generated
vendored
Normal file
286
node_modules/ts-node-dev/lib/index.js
generated
vendored
Normal file
@@ -0,0 +1,286 @@
|
||||
"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.runDev = void 0;
|
||||
var child_process_1 = require("child_process");
|
||||
var chokidar_1 = __importDefault(require("chokidar"));
|
||||
var fs_1 = __importDefault(require("fs"));
|
||||
var readline_1 = __importDefault(require("readline"));
|
||||
var kill = require('tree-kill');
|
||||
var ipc = __importStar(require("./ipc"));
|
||||
var resolveMain_1 = require("./resolveMain");
|
||||
var compiler_1 = require("./compiler");
|
||||
var cfg_1 = require("./cfg");
|
||||
var notify_1 = require("./notify");
|
||||
var log_1 = require("./log");
|
||||
var version = require('../package.json').version;
|
||||
var tsNodeVersion = require('ts-node').VERSION;
|
||||
var tsVersion = require('typescript').version;
|
||||
exports.runDev = function (script, scriptArgs, nodeArgs, opts) {
|
||||
if (typeof script !== 'string' || script.length === 0) {
|
||||
throw new TypeError('`script` must be a string');
|
||||
}
|
||||
if (!Array.isArray(scriptArgs)) {
|
||||
throw new TypeError('`scriptArgs` must be an array');
|
||||
}
|
||||
if (!Array.isArray(nodeArgs)) {
|
||||
throw new TypeError('`nodeArgs` must be an array');
|
||||
}
|
||||
// The child_process
|
||||
var child;
|
||||
var wrapper = resolveMain_1.resolveMain(__dirname + '/wrap.js');
|
||||
var main = resolveMain_1.resolveMain(script);
|
||||
var cfg = cfg_1.makeCfg(main, opts);
|
||||
var log = log_1.makeLog(cfg);
|
||||
var notify = notify_1.makeNotify(cfg, log);
|
||||
// Run ./dedupe.js as preload script
|
||||
if (cfg.dedupe)
|
||||
process.env.NODE_DEV_PRELOAD = __dirname + '/dedupe';
|
||||
function initWatcher() {
|
||||
var watcher = chokidar_1.default.watch([], {
|
||||
usePolling: opts.poll,
|
||||
interval: parseInt(opts.interval) || undefined,
|
||||
});
|
||||
watcher.on('change', restart);
|
||||
watcher.on('fallback', function (limit) {
|
||||
log.warn('node-dev ran out of file handles after watching %s files.', limit);
|
||||
log.warn('Falling back to polling which uses more CPU.');
|
||||
log.info('Run ulimit -n 10000 to increase the file descriptor limit.');
|
||||
if (cfg.deps)
|
||||
log.info('... or add `--no-deps` to use less file handles.');
|
||||
});
|
||||
return watcher;
|
||||
}
|
||||
var watcher = initWatcher();
|
||||
var starting = false;
|
||||
// Read for "rs" from command line
|
||||
if (opts.rs !== false) {
|
||||
var rl = readline_1.default.createInterface({
|
||||
input: process.stdin,
|
||||
output: process.stdout,
|
||||
terminal: false,
|
||||
});
|
||||
rl.on('line', function (line) {
|
||||
if (line.trim() === 'rs') {
|
||||
restart('', true);
|
||||
}
|
||||
});
|
||||
}
|
||||
log.info('ts-node-dev ver. ' +
|
||||
version +
|
||||
' (using ts-node ver. ' +
|
||||
tsNodeVersion +
|
||||
', typescript ver. ' +
|
||||
tsVersion +
|
||||
')');
|
||||
/**
|
||||
* Run the wrapped script.
|
||||
*/
|
||||
var compileReqWatcher;
|
||||
function start() {
|
||||
if (cfg.clear)
|
||||
process.stdout.write('\u001bc');
|
||||
for (var _i = 0, _a = (opts.watch || '').split(','); _i < _a.length; _i++) {
|
||||
var watched = _a[_i];
|
||||
if (watched)
|
||||
watcher.add(watched);
|
||||
}
|
||||
var cmd = nodeArgs.concat(wrapper, script, scriptArgs);
|
||||
var childHookPath = compiler.getChildHookPath();
|
||||
cmd = (opts.priorNodeArgs || []).concat(['-r', childHookPath]).concat(cmd);
|
||||
log.debug('Starting child process %s', cmd.join(' '));
|
||||
child = child_process_1.fork(cmd[0], cmd.slice(1), {
|
||||
cwd: process.cwd(),
|
||||
env: process.env,
|
||||
});
|
||||
starting = false;
|
||||
if (compileReqWatcher) {
|
||||
compileReqWatcher.close();
|
||||
}
|
||||
compileReqWatcher = chokidar_1.default.watch([], {
|
||||
usePolling: opts.poll,
|
||||
interval: parseInt(opts.interval) || undefined,
|
||||
});
|
||||
var currentCompilePath;
|
||||
fs_1.default.writeFileSync(compiler.getCompileReqFilePath(), '');
|
||||
compileReqWatcher.add(compiler.getCompileReqFilePath());
|
||||
compileReqWatcher.on('change', function (file) {
|
||||
fs_1.default.readFile(file, 'utf-8', function (err, data) {
|
||||
if (err) {
|
||||
log.error('Error reading compile request file', err);
|
||||
return;
|
||||
}
|
||||
var split = data.split('\n');
|
||||
var compile = split[0];
|
||||
var compiledPath = split[1];
|
||||
if (currentCompilePath == compiledPath)
|
||||
return;
|
||||
currentCompilePath = compiledPath;
|
||||
if (compiledPath) {
|
||||
compiler.compile({
|
||||
compile: compile,
|
||||
compiledPath: compiledPath,
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
child.on('message', function (message) {
|
||||
if (!message.compiledPath ||
|
||||
currentCompilePath === message.compiledPath) {
|
||||
return;
|
||||
}
|
||||
currentCompilePath = message.compiledPath;
|
||||
compiler.compile(message);
|
||||
});
|
||||
child.on('exit', function (code) {
|
||||
log.debug('Child exited with code %s', code);
|
||||
if (!child)
|
||||
return;
|
||||
if (!child.respawn)
|
||||
process.exit(code || 0);
|
||||
child = undefined;
|
||||
});
|
||||
if (cfg.respawn) {
|
||||
child.respawn = true;
|
||||
}
|
||||
if (compiler.tsConfigPath) {
|
||||
watcher.add(compiler.tsConfigPath);
|
||||
}
|
||||
// Listen for `required` messages and watch the required file.
|
||||
ipc.on(child, 'required', function (m) {
|
||||
var required = m.required;
|
||||
var isIgnored = cfg.ignore.some(isPrefixOf(required)) ||
|
||||
cfg.ignore.some(isRegExpMatch(required));
|
||||
if (!isIgnored && (cfg.deps === -1 || getLevel(required) <= cfg.deps)) {
|
||||
log.debug(required, 'added to watcher');
|
||||
watcher.add(required);
|
||||
}
|
||||
});
|
||||
// Upon errors, display a notification and tell the child to exit.
|
||||
ipc.on(child, 'error', function (m) {
|
||||
log.debug('Child error');
|
||||
notify(m.error, m.message, 'error');
|
||||
stop(m.willTerminate);
|
||||
});
|
||||
compiler.writeReadyFile();
|
||||
}
|
||||
var killChild = function () {
|
||||
if (!child)
|
||||
return;
|
||||
log.debug('Sending SIGTERM kill to child pid', child.pid);
|
||||
if (opts['tree-kill']) {
|
||||
log.debug('Using tree-kill');
|
||||
kill(child.pid);
|
||||
}
|
||||
else {
|
||||
child.kill('SIGTERM');
|
||||
}
|
||||
};
|
||||
function stop(willTerminate) {
|
||||
if (!child || child.stopping) {
|
||||
return;
|
||||
}
|
||||
child.stopping = true;
|
||||
child.respawn = true;
|
||||
if (child.connected === undefined || child.connected === true) {
|
||||
log.debug('Disconnecting from child');
|
||||
child.disconnect();
|
||||
if (!willTerminate) {
|
||||
killChild();
|
||||
}
|
||||
}
|
||||
}
|
||||
function restart(file, isManualRestart) {
|
||||
if (file === compiler.tsConfigPath) {
|
||||
notify('Reinitializing TS compilation', '');
|
||||
compiler.init();
|
||||
}
|
||||
compiler.clearErrorCompile();
|
||||
if (isManualRestart === true) {
|
||||
notify('Restarting', 'manual restart from user');
|
||||
}
|
||||
else {
|
||||
notify('Restarting', file + ' has been modified');
|
||||
}
|
||||
compiler.compileChanged(file);
|
||||
if (starting) {
|
||||
log.debug('Already starting');
|
||||
return;
|
||||
}
|
||||
log.debug('Removing all watchers from files');
|
||||
//watcher.removeAll()ya
|
||||
watcher.close();
|
||||
watcher = initWatcher();
|
||||
starting = true;
|
||||
if (child) {
|
||||
log.debug('Child is still running, restart upon exit');
|
||||
child.on('exit', start);
|
||||
stop();
|
||||
}
|
||||
else {
|
||||
log.debug('Child is already stopped, probably due to a previous error');
|
||||
start();
|
||||
}
|
||||
}
|
||||
// Relay SIGTERM
|
||||
process.on('SIGTERM', function () {
|
||||
log.debug('Process got SIGTERM');
|
||||
killChild();
|
||||
process.exit(0);
|
||||
});
|
||||
var compiler = compiler_1.makeCompiler(opts, {
|
||||
restart: restart,
|
||||
log: log,
|
||||
});
|
||||
compiler.init();
|
||||
start();
|
||||
};
|
||||
/**
|
||||
* Returns the nesting-level of the given module.
|
||||
* Will return 0 for modules from the main package or linked modules,
|
||||
* a positive integer otherwise.
|
||||
*/
|
||||
function getLevel(mod) {
|
||||
var p = getPrefix(mod);
|
||||
return p.split('node_modules').length - 1;
|
||||
}
|
||||
/**
|
||||
* Returns the path up to the last occurence of `node_modules` or an
|
||||
* empty string if the path does not contain a node_modules dir.
|
||||
*/
|
||||
function getPrefix(mod) {
|
||||
var n = 'node_modules';
|
||||
var i = mod.lastIndexOf(n);
|
||||
return ~i ? mod.slice(0, i + n.length) : '';
|
||||
}
|
||||
function isPrefixOf(value) {
|
||||
return function (prefix) {
|
||||
return value.indexOf(prefix) === 0;
|
||||
};
|
||||
}
|
||||
function isRegExpMatch(value) {
|
||||
return function (regExp) {
|
||||
return new RegExp(regExp).test(value);
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user