add new ts sources

Author: wclr

src/bin.ts

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+const dev = require('.')
+import minimist from 'minimist'
+
+const nodeArgs: string[] = []
+const unknown: string[] = []
+
+const devArgs = process.argv.slice(2, 100)
+
+const 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',
+  ],
+}
+
+const tsNodeAlias = {
+  'transpile-only': 'T',
+  'compiler-host': 'H',
+  ignore: 'I',
+  'ignore-diagnostics': 'D',
+  'compiler-options': 'O',
+  compiler: 'C',
+  project: 'P',
+  'script-mode': 's',
+}
+
+type TSNodeOptions = {
+  project: string
+  compilerOptions: any
+  'compiler-options': any
+  'prefer-ts-exts': boolean
+  ignore?: string
+
+  dir: string
+  'script-mode': boolean
+  emit: boolean
+  files: boolean
+  'transpile-only': boolean
+  pretty: boolean
+  scope: boolean
+  'log-error': boolean
+  'skip-project': boolean
+  'skip-ignore': boolean
+  compiler: string
+  'compiler-host': boolean
+  'ignore-diagnostics': string
+}
+
+const devFlags = {
+  boolean: [
+    'deps',
+    'all-deps',
+    'dedupe',
+    'exec-check',
+    'debug',
+    'poll',
+    'respawn',
+    'notify',
+    'tree-kill',
+    'clear',
+    'cls',
+    'exit-child',
+    'error-recompile',
+    'rs',
+  ],
+  string: [
+    'dir',
+    'deps-level',
+    'compile-timeout',
+    'ignore-watch',
+    'interval',
+    'debounce',
+    'watch',
+  ],
+}
+
+type DevOptions = {
+  poll: boolean
+  debug: boolean,
+  watch: string
+  interval: string
+  rs: boolean
+  deps: boolean,
+  dedupe: boolean,
+  respawn: boolean,
+  notify: boolean,
+  clear: boolean,
+  cls: boolean,
+  'ignore-watch': string,
+  'all-deps': boolean,
+  ['deps-level']: string
+  'compile-timeout': string
+  'exec-check': boolean
+  'exit-child': boolean
+  'cache-directory': string
+  'error-recompile': boolean,
+  'tree-kill': boolean
+}
+
+export type Options = {
+  priorNodeArgs: string[]
+  _: string[]
+} & DevOptions &
+  TSNodeOptions
+
+const opts = minimist(devArgs, {
+  stopEarly: true,
+  boolean: [...devFlags.boolean, ...tsNodeFlags.boolean],
+  string: [...devFlags.string, ...tsNodeFlags.string],
+  alias: {
+    ...tsNodeAlias,
+    'prefer-ts-exts': 'prefer-ts',
+  },
+  default: {},
+  unknown: function (arg) {
+    unknown.push(arg)
+    return true
+  },
+}) as Options
+
+const script = opts._[0]
+const scriptArgs = opts._.slice(1)
+
+opts.priorNodeArgs = []
+
+unknown.forEach(function (arg) {
+  if (arg === script || nodeArgs.indexOf(arg) >= 0) return
+
+  const argName = arg.replace(/^-+/, '')
+  // fix this
+  const argOpts = (opts as any)[argName]
+  const 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) {
+  console.log('Usage: ts-node-dev [options] script [arguments]\n')
+  process.exit(1)
+}
+
+dev(script, scriptArgs, nodeArgs, opts)

src/cfg.ts

@@ -0,0 +1,64 @@
+import fs from 'fs'
+import path from 'path'
+import { Options } from './bin'
+
+function read(dir: string) {
+  const f = path.resolve(dir, '.node-dev.json')
+  return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf-8')) : null
+}
+
+function resolvePath(unresolvedPath: string) {
+  return path.resolve(process.cwd(), unresolvedPath)
+}
+
+export type Config = {
+  vm: boolean
+  fork: boolean
+  notify: boolean
+  deps: number
+  timestamp: number
+  clear: boolean
+  dedupe: boolean
+  ignore: string[]
+  respawn: boolean
+  debug: boolean
+  extensions: Record<string, string>
+}
+
+export const makeCfg = (main: string, opts: Partial<Options>): Config => {
+  const dir = main ? path.dirname(main) : '.'
+  const userDir = process.env.HOME || process.env.USERPROFILE
+  const 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
+  }
+  const ignoreWatchItems: string[] = opts['ignore-watch']
+    ? opts['ignore-watch'].split(/,/).map((_) => _.trim())
+    : []
+
+  const ignoreWatch: string[] = ignoreWatchItems.concat(c.ignore || [])  
+  opts.debug && console.log('Ignore watch:', ignoreWatch)
+  const 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,
+    extensions: c.extensions,
+  }
+}

src/check-file-exists.ts

@@ -0,0 +1,13 @@
+import fs from 'fs'
+const filePath = process.argv[2]
+
+const handler = function (stat: fs.Stats) {
+  if (stat && stat.birthtime.getTime() > 0) {
+    process.exit(0)
+  }
+}
+
+fs.watchFile(filePath, { interval: 100 }, handler)
+fs.stat(filePath, function (err, stat) {
+  handler(stat)
+})

src/child-require-hook.ts

@@ -0,0 +1,147 @@
+const fs = require('fs')
+const getCompiledPath = require('./get-compiled-path').getCompiledPath
+const sep = require('path').sep
+const join = require('path').join
+const extname = require('path').extname
+const execSync = require('child_process').execSync
+const Module = require('module')
+const compilationId = ''
+const timeThreshold = 0
+const allowJs = false
+const compiledDir = ''
+const preferTs = false
+const ignore = [/node_modules/]
+const readyFile = ''
+const execCheck = false
+const exitChild = false
+const sourceMapSupportPath = ''
+const libPath = ''
+
+const checkFileScript = join(__dirname, 'check-file-exists.js')
+
+const waitForFile = function (fileName: string) {
+  const start = new Date().getTime()
+  while (true) {
+    const exists = execCheck
+      ? execSync(['node', checkFileScript, '"' + fileName + '"'].join(' '), {
+          stdio: 'inherit',
+        }) || true
+      : fs.existsSync(fileName)
+
+    if (exists) {
+      return
+    }
+    const passed = new Date().getTime() - start
+    if (timeThreshold && passed > timeThreshold) {
+      throw new Error('Could not require ' + fileName)
+    }
+  }
+}
+
+const compile = (code: string, fileName: string) => {
+  const compiledPath = getCompiledPath(code, fileName, compiledDir)
+  process.send &&
+    process.send({
+      compile: fileName,
+      compiledPath: compiledPath,
+    })
+  const compileRequestFile = [compiledDir, compilationId + '.req'].join(sep)
+  fs.writeFileSync(compileRequestFile, [fileName, compiledPath].join('\n'))
+  waitForFile(compiledPath + '.done')
+  const compiled = fs.readFileSync(compiledPath, 'utf-8')
+  return compiled
+}
+
+function registerExtensions(extensions: string[]) {
+  extensions.forEach(function (ext) {
+    const old = require.extensions[ext] || require.extensions['.js']
+    require.extensions[ext] = function (m: any, fileName) {
+      const _compile = m._compile
+      m._compile = function (code: string, fileName: string) {
+        return _compile.call(this, compile(code, fileName), fileName)
+      }
+      return old(m, fileName)
+    }
+  })
+  if (preferTs) {
+    const reorderRequireExtension = (ext: string) => {
+      const old = require.extensions[ext]
+      delete require.extensions[ext]
+      require.extensions[ext] = old
+    }
+    const order = ['.ts', '.tsx'].concat(
+      Object.keys(require.extensions).filter((_) => _ !== '.ts' && _ !== '.tsx')
+    )
+    order.forEach(function (ext) {
+      reorderRequireExtension(ext)
+    })
+  }
+}
+
+function isFileInNodeModules(fileName: string) {
+  return fileName.indexOf(sep + 'node_modules' + sep) >= 0
+}
+
+function registerJsExtension() {
+  const old = require.extensions['.js']
+  // handling preferTs probably redundant after reordering
+  if (allowJs) {
+    require.extensions['.jsx'] = require.extensions['.js'] = function (
+      m: any,
+      fileName
+    ) {
+      if (fileName.indexOf(libPath) === 0) {
+        return old(m, fileName)
+      }
+      const tsCode: string | undefined = undefined
+      const tsFileName = ''
+      const _compile = m._compile
+      const isIgnored =
+        ignore &&
+        ignore.reduce(function (res, ignore) {
+          return res || ignore.test(fileName)
+        }, false)
+      const ext = extname(fileName)
+      if (tsCode !== undefined || (allowJs && !isIgnored && ext == '.js')) {
+        m._compile = function (code: string, fileName: string) {
+          if (tsCode !== undefined) {
+            code = tsCode
+            fileName = tsFileName
+          }
+          return _compile.call(this, compile(code, fileName), fileName)
+        }
+      }
+
+      return old(m, fileName)
+    }
+  }
+}
+
+const sourceMapRequire = Module.createRequire
+  ? Module.createRequire(sourceMapSupportPath)
+  : require
+
+sourceMapRequire(sourceMapSupportPath).install({
+  hookRequire: true,
+})
+
+registerJsExtension()
+registerExtensions(['.ts', '.tsx'])
+
+if (readyFile) {
+  const 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