Improve error messages using formatting and chalk

Author: blakeembrey

package.json

@@ -60,6 +60,7 @@
   },
   "dependencies": {
     "arrify": "^1.0.0",
+    "chalk": "^1.1.1",
     "make-error": "^1.0.2",
     "minimist": "^1.2.0",
     "source-map-support": "^0.3.2",

src/bin/ts-node.ts

@@ -5,7 +5,7 @@ import { readFileSync } from 'fs'
 import Module = require('module')
 import extend = require('xtend')
 import minimist = require('minimist')
-import { register, VERSION } from '../typescript-node'
+import { register, VERSION, TypeScriptError } from '../typescript-node'
 
 interface Argv {
   eval?: string
@@ -52,15 +52,17 @@ if (argv.help) {
   process.exit(0)
 }
 
+const cwd = process.cwd()
+const code = argv.eval == null ? argv.print : argv.eval
+
+// Register the TypeScript compiler instance.
 const compiler = register({
   compiler: argv.compiler,
   ignoreWarnings: list(argv.ignoreWarnings),
-  configFile: argv.compiler
+  configFile: argv.compiler,
+  isRepl: typeof code === 'string' || argv._.length === 0
 })
 
-const cwd = process.cwd()
-const code = argv.eval == null ? argv.print : argv.eval
-
 // TypeScript files must always end with `.ts`.
 const EVAL_FILENAME = '[eval].ts'
 const EVAL_PATH = join(cwd, EVAL_FILENAME)
@@ -77,11 +79,21 @@ if (typeof code === 'string') {
   global.module = module
   global.require = module.require.bind(module)
 
-  var result = _eval(code, EVAL_PATH)
+  let result: any
+
+  try {
+    result = _eval(code, EVAL_PATH)
+  } catch (err) {
+    if (err instanceof TypeScriptError) {
+      console.error(err.message)
+      process.exit(1)
+    }
+
+    throw err
+  }
 
   if (argv.print != null) {
-    var output = typeof result === 'string' ? result : inspect(result)
-    process.stdout.write(output + '\n')
+    console.log(typeof result === 'string' ? result : inspect(result))
   }
 } else {
   if (argv._.length) {
@@ -129,7 +141,11 @@ function replEval (code: string, context: any, filename: string, callback: (err:
   try {
     result = _eval(code, EVAL_PATH)
   } catch (e) {
-    err = e
+    if (e instanceof TypeScriptError) {
+      err = e.message
+    } else {
+      err = e
+    }
   }
 
   callback(err, result)

src/typescript-node.ts

@@ -7,6 +7,7 @@ import { BaseError } from 'make-error'
 import sourceMapSupport = require('source-map-support')
 import extend = require('xtend')
 import arrify = require('arrify')
+import chalk = require('chalk')
 
 /**
  * Export the current version.
@@ -25,6 +26,7 @@ export interface Options {
   compiler?: string
   configFile?: string
   ignoreWarnings?: string[]
+  isRepl?: boolean
 }
 
 /**
@@ -74,8 +76,10 @@ export function register (opts?: Options) {
   const ts: typeof TS = require(options.compiler)
   const config = readConfig(options.configFile, ts)
 
+  // Render the configuration errors and exit the script.
   if (config.errors.length) {
-    throw new TypeScriptError(config.errors, ts)
+    console.error(formatDiagnostics(config.errors, ts))
+    process.exit(1)
   }
 
   const serviceHost: TS.LanguageServiceHost = {
@@ -133,7 +137,14 @@ export function register (opts?: Options) {
     const diagnostics = getDiagnostics(service, fileName, options)
 
     if (diagnostics.length) {
-      throw new TypeScriptError(diagnostics, ts)
+      const message = formatDiagnostics(diagnostics, ts)
+
+      if (opts.isRepl) {
+        throw new TypeScriptError(message)
+      }
+
+      console.error(message)
+      process.exit(1)
     }
 
     return contents
@@ -181,14 +192,23 @@ export function formatDiagnostic (diagnostic: TS.Diagnostic, ts: typeof TS, cwd:
   const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
 
   if (diagnostic.file) {
+    const path = relative(cwd, diagnostic.file.fileName)
     const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start)
 
-    return `${relative(cwd, diagnostic.file.fileName)} (${line + 1},${character + 1}): ${message} (${diagnostic.code})`
+    return `${chalk.gray(`${path} (${line + 1},${character + 1}):`)} ${message} (${diagnostic.code})`
   }
 
   return `${message} (${diagnostic.code})`
 }
 
+/**
+ * Format diagnostics into friendlier errors.
+ */
+function formatDiagnostics (diagnostics: TS.Diagnostic[], ts: typeof TS) {
+  return chalk.red('⨯ Unable to compile TypeScript') +
+    EOL + EOL + diagnostics.map(d => formatDiagnostic(d, ts)).join(EOL)
+}
+
 /**
  * Sanitize the source map content.
  */
@@ -208,14 +228,4 @@ export class TypeScriptError extends BaseError {
 
   name = 'TypeScriptError'
 
-  message: string
-  diagnosticMessages: string[]
-
-  constructor (public diagnostics: TS.Diagnostic[], ts: typeof TS) {
-    super()
-
-    this.diagnosticMessages = diagnostics.map(d => formatDiagnostic(d, ts))
-    this.message = ['Unable to compile TypeScript'].concat(this.diagnosticMessages).join(EOL)
-  }
-
 }

src/typings/make-error.d.ts

@@ -3,5 +3,7 @@ declare module 'make-error' {
     message: string
     name: string
     stack: string
+
+    constructor (message: string)
   }
 }

tsd.json

@@ -19,6 +19,9 @@
     },
     "minimist/minimist.d.ts": {
       "commit": "b3aeee64552e324581fdbe0926f4a96e981e451b"
+    },
+    "chalk/chalk.d.ts": {
+      "commit": "a461a243e2e09b213bc49d12650f80d81047576d"
     }
   }
 }

typings/chalk/chalk.d.ts

@@ -0,0 +1,93 @@
+// Type definitions for chalk v0.4.0
+// Project: https://github.com/sindresorhus/chalk
+// Definitions by: Diullei Gomes <https://github.com/Diullei>, Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module Chalk {
+	export interface ChalkModule extends ChalkStyle {
+		enabled: boolean;
+		supportsColor: boolean;
+		styles: ChalkStyleMap;
+
+		stripColor(value: string): any;
+		hasColor(str:  string): boolean;
+	}
+
+	export interface ChalkChain extends ChalkStyle {
+		(...text: string[]): ChalkChain;
+	}
+
+	export interface ChalkStyleElement {
+		open: string;
+		close: string;
+	}
+
+	export interface ChalkStyle {
+		// General
+		reset: ChalkChain;
+		bold: ChalkChain;
+		italic: ChalkChain;
+		underline: ChalkChain;
+		inverse: ChalkChain;
+		strikethrough: ChalkChain;
+
+		// Text colors
+		black: ChalkChain;
+		red: ChalkChain;
+		green: ChalkChain;
+		yellow: ChalkChain;
+		blue: ChalkChain;
+		magenta: ChalkChain;
+		cyan: ChalkChain;
+		white: ChalkChain;
+		gray: ChalkChain;
+		grey: ChalkChain;
+
+		// Background colors
+		bgBlack: ChalkChain;
+		bgRed: ChalkChain;
+		bgGreen: ChalkChain;
+		bgYellow: ChalkChain;
+		bgBlue: ChalkChain;
+		bgMagenta: ChalkChain;
+		bgCyan: ChalkChain;
+		bgWhite: ChalkChain;
+	}
+
+	export interface ChalkStyleMap {
+		// General
+		reset: ChalkStyleElement;
+		bold: ChalkStyleElement;
+		italic: ChalkStyleElement;
+		underline: ChalkStyleElement;
+		inverse: ChalkStyleElement;
+		strikethrough: ChalkStyleElement;
+
+		// Text colors
+		black: ChalkStyleElement;
+		red: ChalkStyleElement;
+		green: ChalkStyleElement;
+		yellow: ChalkStyleElement;
+		blue: ChalkStyleElement;
+		magenta: ChalkStyleElement;
+		cyan: ChalkStyleElement;
+		white: ChalkStyleElement;
+		gray: ChalkStyleElement;
+
+		// Background colors
+		bgBlack: ChalkStyleElement;
+		bgRed: ChalkStyleElement;
+		bgGreen: ChalkStyleElement;
+		bgYellow: ChalkStyleElement;
+		bgBlue: ChalkStyleElement;
+		bgMagenta: ChalkStyleElement;
+		bgCyan: ChalkStyleElement;
+		bgWhite: ChalkStyleElement;
+	}
+}
+
+declare module "chalk" {
+	var ch: Chalk.ChalkModule;
+	export = ch;
+}
+

typings/tsd.d.ts

@@ -3,3 +3,4 @@
 /// <reference path="node/node.d.ts" />
 /// <reference path="source-map-support/source-map-support.d.ts" />
 /// <reference path="minimist/minimist.d.ts" />
+/// <reference path="chalk/chalk.d.ts" />