victorbatischev/tg-bot-reminder
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Виктор Батищев
2023-08-13 16:48:04 +03:00
commit 73b7dbb0a6
1267 changed files with 1017047 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
node_modules/ts-node-dev/LICENSE generated vendored Normal file
View File

@ -0,0 +1,22 @@
(The MIT License)
Copyright (c) 2014–2015 Felix Gnass
Copyright (c) 2015 Daniel Gasienica
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

90
node_modules/ts-node-dev/README.md generated vendored Normal file
View File

@ -0,0 +1,90 @@
# ts-node-dev
> Tweaked version of [node-dev](https://github.com/fgnass/node-dev) that uses [ts-node](https://github.com/TypeStrong/ts-node) under the hood.
It restarts target node process when any of required files changes (as standard `node-dev`) but shares [Typescript](https://github.com/Microsoft/TypeScript/) compilation process between restarts. This significantly increases speed of restarting comparing to `node-dev -r ts-node/register ...`, `nodemon -x ts-node ...` variations because there is no need to instantiate `ts-node` compilation each time.
## Install
![npm (scoped)](https://img.shields.io/npm/v/ts-node-dev.svg?maxAge=86400) [![Build Status](https://travis-ci.com/wclr/ts-node-dev.svg?branch=master)](https://travis-ci.com/wclr/ts-node-dev)
```
yarn add ts-node-dev --dev
```
```
npm i ts-node-dev --save-dev
```
## Usage
```
ts-node-dev [node-dev|ts-node flags] [ts-node-dev flags] [node cli flags] [--] [script] [script arguments]
```
So you just combine [node-dev](https://github.com/fgnass/node-dev) and [ts-node](https://github.com/TypeStrong/ts-node) options (see docs of those packages):
```
ts-node-dev --respawn --transpile-only server.ts
```
There is also short alias `tsnd` for running `ts-node-dev`:
```
tsnd --respawn server.ts
```
Look up flags and options can be used [in ts-node's docs](https://github.com/TypeStrong/ts-node#cli-and-programmatic-options).
**Also there are additional options specific to `ts-node-dev`:**
* `--ignore-watch` - (default: []) - files/folders to be [ignored by `node-dev`](https://github.com/fgnass/node-dev#ignore-paths). **But this behaviour is enhanced:** it also supports regular expression in the ignore strings and will check absolute paths of required files for match.
* `--deps` - Also watch `node_modules`; by default watching is turned off
* `--debug` - Some additional [DEBUG] output
* `--quiet` - Silent [INFO] messages
* `--interval` - Polling interval (ms) - DOESN'T WORK CURRENTLY
* `--debounce` - Debounce file change events (ms, non-polling mode)
* `--clear` (`--cls`) - Will clear screen on restart
* `--watch` - Explicitly add arbitrary files or folders to watch and restart on change (list separated by commas, [chokidar](https://github.com/paulmillr/chokidar) patterns)
* `--exit-child` - Adds 'SIGTERM' exit handler in a child process.
* `--rs` - Allow to restart with "rs" line entered in stdio, disabled by default.
* `--notify` - to display desktop-notifications (Notifications are only displayed if `node-notifier` is installed).
* `--cache-directory` - tmp dir which is used to keep the compiled sources (by default os tmp directory is used)
If you need to detect that you are running with `ts-node-dev`, check if `process.env.TS_NODE_DEV` is set.
**Points of notice:**
- If you want desktop-notifications you should install `node-notifier` package and use `--notify` flag.
- Especially for large code bases always consider running with `--transpile-only` flag which is normal for dev workflow and will speed up things greatly. Note, that `ts-node-dev` will not put watch handlers on TS files that contain only types/interfaces (used only for type checking) - this is current limitation by design.
- `--ignore-watch` will NOT affect files ignored by TS compilation. Use `--ignore` option (or `TS_NODE_IGNORE` env variable) to pass **RegExp strings** for filtering files that should not be compiled, by default `/node_modules/` are ignored.
- Unknown flags (`node` cli flags are considered to be so) are treated like string value flags by default. The right solution to avoid ambiguity is to separate script name from option flags with `--`, for example:
```
ts-node-dev --inspect -- my-script.ts
```
- The good thing is that `ts-node-dev` watches used `tsconfig.json` file, and will reinitialize compilation on its change, but you have to restart the process manually when you update used version of `typescript` or make any other changes that may effect compilation results.
## Issues
If you have an issue, please create one. But, before:
- try to check if there exits alike issues.
- try to run your code with just [ts-node](https://github.com/TypeStrong/ts-node)
- try to run your code with `--files` option enabled ([see ts-node docs](https://github.com/TypeStrong/ts-node#help-my-types-are-missing))
- try to run it with `--debug` flag and see the output
- try to make create repro example
## Versioning
Currently versioning is not stable and it is still treated as pre-release. You might expect some options API changes. If you want to avoid unexpected problems it is recommended to fixate the installed version and update only in case of issues, you may consult [CHANGELOG](CHANGELOG.md) for updates.
## License
MIT.

BIN
node_modules/ts-node-dev/icons/node_error.png generated vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 636 B

BIN
node_modules/ts-node-dev/icons/node_info.png generated vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 636 B

136
node_modules/ts-node-dev/lib/bin.js generated vendored Executable file
View File

@ -0,0 +1,136 @@
#!/usr/bin/env node
"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 __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var _1 = require(".");
var minimist_1 = __importDefault(require("minimist"));
var nodeArgs = [];
var unknown = [];
var devArgs = process.argv.slice(2, 100);
var tsNodeFlags = {
boolean: [
'scope',
'emit',
'files',
'pretty',
'transpile-only',
'prefer-ts-exts',
'prefer-ts',
'log-error',
'skip-project',
'skip-ignore',
'compiler-host',
'script-mode',
],
string: [
'compiler',
'project',
'ignore',
'ignore-diagnostics',
'compiler-options',
'scopeDir',
'transpiler'
],
};
var tsNodeAlias = {
'transpile-only': 'T',
'compiler-host': 'H',
ignore: 'I',
'ignore-diagnostics': 'D',
'compiler-options': 'O',
compiler: 'C',
project: 'P',
'script-mode': 's',
};
var devFlags = {
boolean: [
'deps',
'all-deps',
'dedupe',
'fork',
'exec-check',
'debug',
'poll',
'respawn',
'notify',
'tree-kill',
'clear',
'cls',
'exit-child',
'error-recompile',
'quiet',
'rs',
],
string: [
'dir',
'deps-level',
'compile-timeout',
'ignore-watch',
'interval',
'debounce',
'watch',
'cache-directory',
],
};
var opts = minimist_1.default(devArgs, {
stopEarly: true,
boolean: __spreadArrays(devFlags.boolean, tsNodeFlags.boolean),
string: __spreadArrays(devFlags.string, tsNodeFlags.string),
alias: __assign(__assign({}, tsNodeAlias), { 'prefer-ts-exts': 'prefer-ts' }),
default: {
fork: true,
},
unknown: function (arg) {
unknown.push(arg);
return true;
},
});
var script = opts._[0];
var scriptArgs = opts._.slice(1);
opts.priorNodeArgs = [];
unknown.forEach(function (arg) {
if (arg === script || nodeArgs.indexOf(arg) >= 0)
return;
var argName = arg.replace(/^-+/, '');
// fix this
var argOpts = opts[argName];
var argValues = Array.isArray(argOpts) ? argOpts : [argOpts];
argValues.forEach(function (argValue) {
if ((arg === '-r' || arg === '--require') && argValue === 'esm') {
opts.priorNodeArgs.push(arg, argValue);
return false;
}
nodeArgs.push(arg);
if (typeof argValue === 'string') {
nodeArgs.push(argValue);
}
});
});
if (!script) {
// eslint-disable-next-line no-console
console.log('ts-node-dev: no script to run provided');
// eslint-disable-next-line no-console
console.log('Usage: ts-node-dev [options] script [arguments]\n');
process.exit(1);
}
_1.runDev(script, scriptArgs, nodeArgs, opts);

59
node_modules/ts-node-dev/lib/cfg.js generated vendored Normal file
View File

@ -0,0 +1,59 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeCfg = void 0;
var fs_1 = __importDefault(require("fs"));
var path_1 = __importDefault(require("path"));
function read(dir) {
var f = path_1.default.resolve(dir, '.node-dev.json');
return fs_1.default.existsSync(f) ? JSON.parse(fs_1.default.readFileSync(f, 'utf-8')) : null;
}
function resolvePath(unresolvedPath) {
return path_1.default.resolve(process.cwd(), unresolvedPath);
}
exports.makeCfg = function (main, opts) {
var dir = main ? path_1.default.dirname(main) : '.';
var userDir = process.env.HOME || process.env.USERPROFILE;
var c = read(dir) || read(process.cwd()) || (userDir && read(userDir)) || {};
c.deps = parseInt(opts['deps-level'] || '') || 0;
if (typeof c.depsLevel === 'number')
c.deps = c.depsLevel;
if (opts) {
// Overwrite with CLI opts ...
if (opts['deps'] || opts['all-deps'])
c.deps = -1;
if (opts.dedupe)
c.dedupe = true;
if (opts.respawn)
c.respawn = true;
if (opts.notify === false)
c.notify = false;
if (opts.clear || opts.cls)
c.clear = true;
c.fork = opts.fork;
}
var ignoreWatchItems = opts['ignore-watch']
? []
.concat(opts['ignore-watch'])
.map(function (_) { return _.trim(); })
: [];
var ignoreWatch = ignoreWatchItems.concat(c.ignore || []);
opts.debug && console.log('Ignore watch:', ignoreWatch);
var ignore = ignoreWatch.concat(ignoreWatch.map(resolvePath));
return {
vm: c.vm !== false,
fork: c.fork !== false,
notify: c.notify !== false,
deps: c.deps,
timestamp: c.timestamp || (c.timestamp !== false && 'HH:MM:ss'),
clear: !!c.clear,
dedupe: !!c.dedupe,
ignore: ignore,
respawn: c.respawn || false,
debug: !!opts.debug,
quiet: !!opts.quiet,
extensions: c.extensions,
};
};

16
node_modules/ts-node-dev/lib/check-file-exists.js generated vendored Normal file
View File

@ -0,0 +1,16 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var fs_1 = __importDefault(require("fs"));
var filePath = process.argv[2];
var handler = function (stat) {
if (stat && stat.birthtime.getTime() > 0) {
process.exit(0);
}
};
fs_1.default.watchFile(filePath, { interval: 100 }, handler);
fs_1.default.stat(filePath, function (err, stat) {
handler(stat);
});

140
node_modules/ts-node-dev/lib/child-require-hook.js generated vendored Normal file
View File

@ -0,0 +1,140 @@
"use strict";
var fs = require('fs');
var getCompiledPath = require('./get-compiled-path').getCompiledPath;
var sep = require('path').sep;
var join = require('path').join;
var extname = require('path').extname;
var execSync = require('child_process').execSync;
var Module = require('module');
var compilationId = '';
var timeThreshold = 0;
var allowJs = false;
var compiledDir = '';
var preferTs = false;
var ignore = [/node_modules/];
var readyFile = '';
var execCheck = false;
var exitChild = false;
var sourceMapSupportPath = '';
var libPath = '';
var checkFileScript = join(__dirname, 'check-file-exists.js');
var waitForFile = function (fileName) {
var start = new Date().getTime();
while (true) {
var exists = execCheck
? execSync(['node', checkFileScript, '"' + fileName + '"'].join(' '), {
stdio: 'inherit',
}) || true
: fs.existsSync(fileName);
if (exists) {
return;
}
var passed = new Date().getTime() - start;
if (timeThreshold && passed > timeThreshold) {
throw new Error('Could not require ' + fileName);
}
}
};
var sendFsCompileRequest = function (fileName, compiledPath) {
var compileRequestFile = [compiledDir, compilationId + '.req'].join(sep);
fs.writeFileSync(compileRequestFile, [fileName, compiledPath].join('\n'));
};
var compile = function (code, fileName) {
var compiledPath = getCompiledPath(code, fileName, compiledDir);
if (process.send) {
try {
process.send({
compile: fileName,
compiledPath: compiledPath,
});
}
catch (e) {
console.warn('Error while sending compile request via process.send');
sendFsCompileRequest(fileName, compiledPath);
}
}
else {
sendFsCompileRequest(fileName, compiledPath);
}
waitForFile(compiledPath + '.done');
var compiled = fs.readFileSync(compiledPath, 'utf-8');
return compiled;
};
function registerExtensions(extensions) {
extensions.forEach(function (ext) {
var old = require.extensions[ext] || require.extensions['.js'];
require.extensions[ext] = function (m, fileName) {
var _compile = m._compile;
m._compile = function (code, fileName) {
return _compile.call(this, compile(code, fileName), fileName);
};
return old(m, fileName);
};
});
if (preferTs) {
var reorderRequireExtension_1 = function (ext) {
var old = require.extensions[ext];
delete require.extensions[ext];
require.extensions[ext] = old;
};
var order = ['.ts', '.tsx'].concat(Object.keys(require.extensions).filter(function (_) { return _ !== '.ts' && _ !== '.tsx'; }));
order.forEach(function (ext) {
reorderRequireExtension_1(ext);
});
}
}
function isFileInNodeModules(fileName) {
return fileName.indexOf(sep + 'node_modules' + sep) >= 0;
}
function registerJsExtension() {
var old = require.extensions['.js'];
// handling preferTs probably redundant after reordering
if (allowJs) {
require.extensions['.jsx'] = require.extensions['.js'] = function (m, fileName) {
if (fileName.indexOf(libPath) === 0) {
return old(m, fileName);
}
var tsCode = undefined;
var tsFileName = '';
var _compile = m._compile;
var isIgnored = ignore &&
ignore.reduce(function (res, ignore) {
return res || ignore.test(fileName);
}, false);
var ext = extname(fileName);
if (tsCode !== undefined || (allowJs && !isIgnored && ext == '.js')) {
m._compile = function (code, fileName) {
if (tsCode !== undefined) {
code = tsCode;
fileName = tsFileName;
}
return _compile.call(this, compile(code, fileName), fileName);
};
}
return old(m, fileName);
};
}
}
var sourceMapRequire = Module.createRequire
? Module.createRequire(sourceMapSupportPath)
: require;
sourceMapRequire(sourceMapSupportPath).install({
hookRequire: true,
});
registerJsExtension();
registerExtensions(['.ts', '.tsx']);
if (readyFile) {
var time = new Date().getTime();
while (!fs.existsSync(readyFile)) {
if (new Date().getTime() - time > 5000) {
throw new Error('Waiting ts-node-dev ready file failed');
}
}
}
if (exitChild) {
process.on('SIGTERM', function () {
console.log('Child got SIGTERM, exiting.');
process.exit();
});
}
module.exports.registerExtensions = registerExtensions;

290
node_modules/ts-node-dev/lib/compiler.js generated vendored Normal file
View File

@ -0,0 +1,290 @@
"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'];
var parse = function (value) {
return typeof value === 'string' ? JSON.parse(value) : undefined;
};
function split(value) {
return typeof value === 'string'
? value.split(/ *, */g).filter(function (v) { return v !== ''; })
: undefined;
}
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;
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'],
scopeDir: options['scopeDir'],
emit: options['emit'],
files: options['files'],
pretty: options['pretty'],
transpileOnly: options['transpile-only'],
ignore: options['ignore'] ? split(options['ignore']) : undefined,
preferTsExts: options['prefer-ts-exts'],
logError: options['log-error'],
project: options['project'],
skipProject: options['skip-project'],
transpiler: options['transpiler'],
skipIgnore: options['skip-ignore'],
compiler: options['compiler'],
compilerHost: options['compiler-host'],
ignoreDiagnostics: options['ignore-diagnostics']
? split(options['ignore-diagnostics'])
: undefined,
compilerOptions: 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;
};

2
node_modules/ts-node-dev/lib/dedupe.js generated vendored Normal file
View File

@ -0,0 +1,2 @@
"use strict";
require('dynamic-dedupe').activate();

18
node_modules/ts-node-dev/lib/get-compiled-path.js generated vendored Normal file
View File

@ -0,0 +1,18 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getCompiledPath = void 0;
var crypto_1 = __importDefault(require("crypto"));
var path_1 = __importDefault(require("path"));
var cwd = process.cwd();
exports.getCompiledPath = function (code, fileName, compiledDir) {
var hash = crypto_1.default
.createHash('sha256')
.update(fileName + code, 'utf8')
.digest('hex');
fileName = path_1.default.relative(cwd, fileName);
var hashed = fileName.replace(/[^\w]/g, '_') + '_' + hash + '.js';
return path_1.default.join(compiledDir, hashed);
};

49
node_modules/ts-node-dev/lib/get-cwd.js generated vendored Normal file
View File

@ -0,0 +1,49 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getCwd = void 0;
var path_1 = __importDefault(require("path"));
var hasOwnProperty = function (object, property) {
return Object.prototype.hasOwnProperty.call(object, property);
};
exports.getCwd = function (dir, scriptMode, scriptPath) {
if (scriptMode) {
if (!scriptPath) {
console.error('Script mode must be used with a script name, e.g. `ts-node-dev -s <script.ts>`');
process.exit();
}
if (dir) {
console.error('Script mode cannot be combined with `--dir`');
process.exit();
}
// Use node's own resolution behavior to ensure we follow symlinks.
// scriptPath may omit file extension or point to a directory with or without package.json.
// This happens before we are registered, so we tell node's resolver to consider ts, tsx, and jsx files.
// In extremely rare cases, is is technically possible to resolve the wrong directory,
// because we do not yet know preferTsExts, jsx, nor allowJs.
// See also, justification why this will not happen in real-world situations:
// https://github.com/TypeStrong/ts-node/pull/1009#issuecomment-613017081
var exts = ['.js', '.jsx', '.ts', '.tsx'];
var extsTemporarilyInstalled = [];
for (var _i = 0, exts_1 = exts; _i < exts_1.length; _i++) {
var ext = exts_1[_i];
if (!hasOwnProperty(require.extensions, ext)) {
// tslint:disable-line
extsTemporarilyInstalled.push(ext);
require.extensions[ext] = function () { }; // tslint:disable-line
}
}
try {
return path_1.default.dirname(require.resolve(scriptPath));
}
finally {
for (var _a = 0, extsTemporarilyInstalled_1 = extsTemporarilyInstalled; _a < extsTemporarilyInstalled_1.length; _a++) {
var ext = extsTemporarilyInstalled_1[_a];
delete require.extensions[ext]; // tslint:disable-line
}
}
}
return dir;
};

68
node_modules/ts-node-dev/lib/hook.js generated vendored Normal file
View File

@ -0,0 +1,68 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeHook = void 0;
var vm_1 = __importDefault(require("vm"));
exports.makeHook = function (cfg, wrapper, callback) {
// Hook into Node's `require(...)`
updateHooks();
// Patch the vm module to watch files executed via one of these methods:
if (cfg.vm) {
patch(vm_1.default, 'createScript', 1);
patch(vm_1.default, 'runInThisContext', 1);
patch(vm_1.default, 'runInNewContext', 2);
patch(vm_1.default, 'runInContext', 2);
}
/**
* Patch the specified method to watch the file at the given argument
* index.
*/
function patch(obj, method, optionsArgIndex) {
var orig = obj[method];
if (!orig)
return;
obj[method] = function () {
var opts = arguments[optionsArgIndex];
var file = null;
if (opts) {
file = typeof opts == 'string' ? opts : opts.filename;
}
if (file)
callback(file);
return orig.apply(this, arguments);
};
}
/**
* (Re-)install hooks for all registered file extensions.
*/
function updateHooks() {
Object.keys(require.extensions).forEach(function (ext) {
var fn = require.extensions[ext];
if (typeof fn === 'function' && fn.name !== 'nodeDevHook') {
require.extensions[ext] = createHook(fn);
}
});
}
/**
* Returns a function that can be put into `require.extensions` in order to
* invoke the callback when a module is required for the first time.
*/
function createHook(handler) {
return function nodeDevHook(module, filename) {
if (module.parent === wrapper) {
// If the main module is required conceal the wrapper
module.id = '.';
module.parent = null;
process.mainModule = module;
}
if (!module.loaded)
callback(module.filename);
// Invoke the original handler
handler(module, filename);
// Make sure the module did not hijack the handler
updateHooks();
};
}
};

286
node_modules/ts-node-dev/lib/index.js generated vendored Normal file
View 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);
};
}

35
node_modules/ts-node-dev/lib/ipc.js generated vendored Normal file
View File

@ -0,0 +1,35 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.relay = exports.on = exports.send = void 0;
/**
* Checks if the given message is an internal node-dev message.
*/
function isNodeDevMessage(m) {
return m.cmd === 'NODE_DEV';
}
/**
* Sends a message to the given process.
*/
exports.send = function (m, dest) {
if (dest === void 0) { dest = process; }
m.cmd = 'NODE_DEV';
if (dest.send)
dest.send(m);
};
exports.on = function (proc, type, cb) {
function handleMessage(m) {
if (isNodeDevMessage(m) && type in m)
cb(m);
}
proc.on('internalMessage', handleMessage);
proc.on('message', handleMessage);
};
exports.relay = function (src, dest) {
if (dest === void 0) { dest = process; }
function relayMessage(m) {
if (isNodeDevMessage(m))
dest.send(m);
}
src.on('internalMessage', relayMessage);
src.on('message', relayMessage);
};

50
node_modules/ts-node-dev/lib/log.js generated vendored Normal file
View File

@ -0,0 +1,50 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeLog = void 0;
var util = require('util');
var colors = {
info: '36',
error: '31;1',
warn: '33',
debug: '90',
};
var formatDate = function (date) {
return [date.getHours(), date.getMinutes(), date.getSeconds()]
.map(function (n) { return n.toString().padStart(2, '0'); })
.join(':');
};
/**
* Logs a message to the console. The level is displayed in ANSI colors,
* either bright red in case of an error or green otherwise.
*/
exports.makeLog = function (cfg) {
function log(msg, level) {
if (cfg.quiet && level === 'info')
return;
if (cfg.timestamp)
msg = color(formatDate(new Date()), '30;1') + ' ' + msg;
var c = colors[level.toLowerCase()] || '32';
console.log('[' + color(level.toUpperCase(), c) + '] ' + msg);
}
function color(s, c) {
if (process.stdout.isTTY) {
return '\x1B[' + c + 'm' + s + '\x1B[0m';
}
return s;
}
log.debug = function () {
if (!cfg.debug)
return;
log(util.format.apply(util, arguments), 'debug');
};
log.info = function () {
log(util.format.apply(util, arguments), 'info');
};
log.warn = function () {
log(util.format.apply(util, arguments), 'warn');
};
log.error = function () {
log(util.format.apply(util, arguments), 'error');
};
return log;
};

33
node_modules/ts-node-dev/lib/notify.js generated vendored Normal file
View File

@ -0,0 +1,33 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeNotify = void 0;
var path_1 = __importDefault(require("path"));
var notifier = null;
try {
notifier = require('node-notifier');
}
catch (error) {
notifier = null;
}
function icon(level) {
return path_1.default.resolve(__dirname, '../icons/node_' + level + '.png');
}
/**
* Displays a desktop notification and writes a message to the console.
*/
exports.makeNotify = function (cfg, log) {
return function (title, msg, level) {
level = level || 'info';
log([title, msg].filter(function (_) { return _; }).join(': '), level);
if (notifier !== null && cfg.notify) {
notifier.notify({
title: title || 'node.js',
icon: icon(level),
message: msg,
});
}
};
};

33
node_modules/ts-node-dev/lib/resolveMain.js generated vendored Normal file
View File

@ -0,0 +1,33 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveMain = void 0;
var resolve = require('resolve');
function resolveRequest(req) {
// The `resolve` package is prebuilt through ncc, which prevents
// PnP from being able to inject itself into it. To circumvent
// this, we simply use PnP directly when available.
if (process.versions.pnp) {
var resolveRequest_1 = require("pnpapi").resolveRequest;
return resolveRequest_1(req, process.cwd() + '/');
}
else {
var opts = {
basedir: process.cwd(),
paths: [process.cwd()],
};
return resolve.sync(req, opts);
}
}
exports.resolveMain = function (main) {
try {
return resolveRequest(main + '.ts');
}
catch (e) {
try {
return resolveRequest(main + '/index.ts');
}
catch (e) {
return resolveRequest(main);
}
}
};

104
node_modules/ts-node-dev/lib/wrap.js generated vendored Normal file
View File

@ -0,0 +1,104 @@
"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;
};
Object.defineProperty(exports, "__esModule", { value: true });
var childProcess = require('child_process');
var child_process_1 = require("child_process");
var resolve = require('resolve').sync;
var hook_1 = require("./hook");
var ipc = __importStar(require("./ipc"));
var resolveMain_1 = require("./resolveMain");
var cfg_1 = require("./cfg");
// const Module = require('module')
// Remove wrap.js from the argv array
process.argv.splice(1, 1);
// Resolve the location of the main script relative to cwd
var main = resolveMain_1.resolveMain(process.argv[1]);
var cfg = cfg_1.makeCfg(main, {});
if (process.env.TS_NODE_DEV === undefined) {
process.env.TS_NODE_DEV = 'true';
}
if (process.env.NODE_DEV_PRELOAD) {
require(process.env.NODE_DEV_PRELOAD);
}
// Listen SIGTERM and exit unless there is another listener
process.on('SIGTERM', function () {
if (process.listeners('SIGTERM').length === 1)
process.exit(0);
});
if (cfg.fork) {
var oldFork_1 = child_process_1.fork;
// Overwrite child_process.fork() so that we can hook into forked processes
// too. We also need to relay messages about required files to the parent.
var newFork = function (modulePath, args, options) {
var child = oldFork_1(__filename, [modulePath].concat(args), options);
ipc.relay(child);
return child;
};
childProcess.fork = newFork;
}
// const lastRequired = null
// const origRequire = Module.prototype.require
// Module.prototype.require = function (requirePath) {
// lastRequired = { path: requirePath, filename: this.filename }
// return origRequire.apply(this, arguments)
// }
// Error handler that displays a notification and logs the stack to stderr:
var caught = false;
process.on('uncaughtException', function (err) {
// NB: err can be null
// Handle exception only once
if (caught)
return;
caught = true;
// If there's a custom uncaughtException handler expect it to terminate
// the process.
var hasCustomHandler = process.listeners('uncaughtException').length > 1;
var isTsError = err && err.message && /TypeScript/.test(err.message);
if (!hasCustomHandler && !isTsError) {
console.error((err && err.stack) || err);
}
ipc.send({
error: isTsError ? '' : (err && err.name) || 'Error',
// lastRequired: lastRequired,
message: err ? err.message : '',
code: err && err.code,
willTerminate: hasCustomHandler,
});
});
// Hook into require() and notify the parent process about required files
hook_1.makeHook(cfg, module, function (file) {
ipc.send({ required: file });
});
// Check if a module is registered for this extension
// const ext = path.extname(main).slice(1)
// const mod = cfg.extensions[ext]
// // Support extensions where 'require' returns a function that accepts options
// if (typeof mod == 'object' && mod.name) {
// const fn = require(resolve(mod.name, { basedir: path.dirname(main) }))
// if (typeof fn == 'function' && mod.options) {
// // require returned a function, call it with options
// fn(mod.options)
// }
// } else if (typeof mod == 'string') {
// require(resolve(mod, { basedir: path.dirname(main) }))
// }
// Execute the wrapped script
require(main);

101
node_modules/ts-node-dev/package.json generated vendored Normal file
View File

@ -0,0 +1,101 @@
{
"name": "ts-node-dev",
"version": "2.0.0",
"description": "Compiles your TS app and restarts when files are modified.",
"keywords": [
"restart",
"reload",
"supervisor",
"monitor",
"watch"
],
"repository": {
"type": "git",
"url": "http://github.com/whitecolor/ts-node-dev.git"
},
"license": "MIT",
"bin": {
"ts-node-dev": "lib/bin.js",
"tsnd": "lib/bin.js"
},
"main": "lib",
"files": [
"icons",
"lib"
],
"prettier": {
"singleQuote": true,
"semi": false
},
"engines": {
"node": ">=0.8.0"
},
"scripts": {
"ts-node-dev": "node ./lib/bin",
"build": "tsc -p tsconfig.build.json",
"release": "np",
"test": "yarn build && ts-node -T node_modules/mocha/bin/mocha test/*.test.ts",
"test-dev": "yarn ts-node-dev -T --respawn --deps --watch lib node_modules/mocha/bin/mocha test/*.test.ts --output",
"test-docker": "docker-compose up",
"ci": "yarn test",
"ci-local": "docker run --name travis-debug -dit quay.io/travisci/ci-nodejs",
"manual": "yarn ts-node test/manual/run.ts"
},
"dependencies": {
"chokidar": "^3.5.1",
"dynamic-dedupe": "^0.3.0",
"minimist": "^1.2.6",
"mkdirp": "^1.0.4",
"resolve": "^1.0.0",
"rimraf": "^2.6.1",
"source-map-support": "^0.5.12",
"tree-kill": "^1.2.2",
"ts-node": "^10.4.0",
"tsconfig": "^7.0.0"
},
"devDependencies": {
"@types/chai": "^4.2.12",
"@types/chokidar": "^2.1.3",
"@types/fs-extra": "^9.0.1",
"@types/minimist": "^1.2.0",
"@types/mkdirp": "^1.0.1",
"@types/mocha": "github:whitecolor/mocha-types",
"@types/node": "^14.6.0",
"@types/rimraf": "^3.0.0",
"@types/tape": "^4.13.0",
"@types/touch": "^3.1.1",
"@types/ts-nameof": "^4.2.1",
"@whitecolor/eslint-config": "^1.0.0",
"chai": "^4.2.0",
"chalk": "^4.1.0",
"coffee-script": "^1.8.0",
"eslint": "^7.7.0",
"esm": "^3.2.22",
"fs-extra": "^9.0.1",
"mocha": "^8.1.1",
"np": "^7.6.1",
"tap": "^5.2.0",
"tape": "^5.0.1",
"touch": "^1.0.0",
"ts-nameof": "^5.0.0",
"tsconfig-paths": "^3.3.1",
"ttypescript": "^1.5.10",
"typescript": "^3.9.5"
},
"peerDependencies": {
"node-notifier": "*",
"typescript": "*"
},
"peerDependenciesMeta": {
"node-notifier": {
"optional": true
}
},
"np": {
"yarn": false,
"cleanup": false
},
"publishConfig": {
"registry": "https://registry.npmjs.org"
}
}