chalk 2.0.1 → 2.3.0

package/index.js

@@ -19,13 +19,14 @@ function applyOptions(obj, options) {
 	options = options || {};
 
 	// Detect level if not set manually
-	obj.level = options.level === undefined ? supportsColor.level : options.level;
+	const scLevel = supportsColor ? supportsColor.level : 0;
+	obj.level = options.level === undefined ? scLevel : options.level;
 	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
 }
 
 function Chalk(options) {
-	// We check for this.template here since calling chalk.constructor()
-	// by itself will have a `this` of a previously constructed chalk object.
+	// We check for this.template here since calling `chalk.constructor()`
+	// by itself will have a `this` of a previously constructed chalk object
 	if (!this || !(this instanceof Chalk) || this.template) {
 		const chalk = {};
 		applyOptions(chalk, options);
@@ -57,11 +58,17 @@ for (const key of Object.keys(ansiStyles)) {
 	styles[key] = {
 		get() {
 			const codes = ansiStyles[key];
-			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], key);
+			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
 		}
 	};
 }
 
+styles.visible = {
+	get() {
+		return build.call(this, this._styles || [], true, 'visible');
+	}
+};
+
 ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
 for (const model of Object.keys(ansiStyles.color.ansi)) {
 	if (skipModels.has(model)) {
@@ -78,7 +85,7 @@ for (const model of Object.keys(ansiStyles.color.ansi)) {
 					close: ansiStyles.color.close,
 					closeRe: ansiStyles.color.closeRe
 				};
-				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], model);
+				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
 			};
 		}
 	};
@@ -101,7 +108,7 @@ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
 					close: ansiStyles.bgColor.close,
 					closeRe: ansiStyles.bgColor.closeRe
 				};
-				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], model);
+				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
 			};
 		}
 	};
@@ -109,12 +116,13 @@ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
 
 const proto = Object.defineProperties(() => {}, styles);
 
-function build(_styles, key) {
+function build(_styles, _empty, key) {
 	const builder = function () {
 		return applyStyle.apply(builder, arguments);
 	};
 
 	builder._styles = _styles;
+	builder._empty = _empty;
 
 	const self = this;
 
@@ -142,7 +150,7 @@ function build(_styles, key) {
 	builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
 
 	// `__proto__` is used because we must return a function, but there is
-	// no way to create a function with a different prototype.
+	// no way to create a function with a different prototype
 	builder.__proto__ = proto; // eslint-disable-line no-proto
 
 	return builder;
@@ -152,7 +160,11 @@ function applyStyle() {
 	// Support varags, but simply cast to string in case there's only one arg
 	const args = arguments;
 	const argsLen = args.length;
-	let str = argsLen !== 0 && String(arguments[0]);
+	let str = String(arguments[0]);
+
+	if (argsLen === 0) {
+		return '';
+	}
 
 	if (argsLen > 1) {
 		// Don't slice `arguments`, it prevents V8 optimizations
@@ -162,7 +174,7 @@ function applyStyle() {
 	}
 
 	if (!this.enabled || this.level <= 0 || !str) {
-		return str;
+		return this._empty ? '' : str;
 	}
 
 	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
@@ -192,17 +204,18 @@ function applyStyle() {
 }
 
 function chalkTag(chalk, strings) {
-	const args = [].slice.call(arguments, 2);
-
 	if (!Array.isArray(strings)) {
-		return strings.toString();
+		// If chalk() was called by itself or with a string,
+		// return the string itself as a string.
+		return [].slice.call(arguments, 1).join(' ');
 	}
 
+	const args = [].slice.call(arguments, 2);
 	const parts = [strings.raw[0]];
 
 	for (let i = 1; i < strings.length; i++) {
-		parts.push(args[i - 1].toString().replace(/[{}]/g, '\\$&'));
-		parts.push(strings.raw[i]);
+		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+		parts.push(String(strings.raw[i]));
 	}
 
 	return template(chalk, parts.join(''));
@@ -212,3 +225,4 @@ Object.defineProperties(Chalk.prototype, styles);
 
 module.exports = Chalk(); // eslint-disable-line new-cap
 module.exports.supportsColor = supportsColor;
+module.exports.default = module.exports; // For TypeScript

package/package.json

@@ -1,20 +1,21 @@
 {
 	"name": "chalk",
-	"version": "2.0.1",
-	"description": "Terminal string styling done right. Much color",
+	"version": "2.3.0",
+	"description": "Terminal string styling done right",
 	"license": "MIT",
 	"repository": "chalk/chalk",
 	"engines": {
 		"node": ">=4"
 	},
 	"scripts": {
-		"test": "xo && nyc mocha",
+		"test": "xo && tsc --project types && nyc ava",
 		"bench": "matcha benchmark.js",
 		"coveralls": "nyc report --reporter=text-lcov | coveralls"
 	},
 	"files": [
 		"index.js",
-		"templates.js"
+		"templates.js",
+		"types/index.d.ts"
 	],
 	"keywords": [
 		"color",
@@ -45,14 +46,17 @@
 		"supports-color": "^4.0.0"
 	},
 	"devDependencies": {
-		"coveralls": "^2.11.2",
+		"ava": "*",
+		"coveralls": "^3.0.0",
+		"execa": "^0.8.0",
 		"import-fresh": "^2.0.0",
 		"matcha": "^0.7.0",
-		"mocha": "*",
 		"nyc": "^11.0.2",
-		"resolve-from": "^3.0.0",
+		"resolve-from": "^4.0.0",
+		"typescript": "^2.5.3",
 		"xo": "*"
 	},
+	"types": "types/index.d.ts",
 	"xo": {
 		"envs": [
 			"node",

package/readme.md

@@ -9,11 +9,9 @@
 
 > Terminal string styling done right
 
-[![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk) [![Coverage Status](https://coveralls.io/repos/github/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/github/chalk/chalk?branch=master) [![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo)
+[![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk) [![Coverage Status](https://coveralls.io/repos/github/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/github/chalk/chalk?branch=master) [![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo) [![Mentioned in Awesome Node.js](https://awesome.re/mentioned-badge.svg)](https://github.com/sindresorhus/awesome-nodejs)
 
-[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68). Although there are other ones, they either do too much or not enough.
-
-**Chalk is a clean and focused alternative.**
+### [See what's new in Chalk 2](https://github.com/chalk/chalk/releases/tag/v2.0.0)
 
 ![](https://github.com/chalk/ansi-styles/raw/master/screenshot.png)
 
@@ -172,6 +170,7 @@ Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=
 - `inverse`
 - `hidden`
 - `strikethrough` *(Not widely supported)*
+- `visible` (Text is emitted only if enabled)
 
 ### Colors
 
@@ -183,8 +182,7 @@ Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=
 - `magenta`
 - `cyan`
 - `white`
-- `gray`
-- `blackBright`
+- `gray` ("bright black")
 - `redBright`
 - `greenBright`
 - `yellowBright`
@@ -278,17 +276,26 @@ The following color models can be used:
 If you're on Windows, do yourself a favor and use [`cmder`](http://cmder.net/) instead of `cmd.exe`.
 
 
+## Origin story
+
+[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68) and the package is unmaintained. Although there are other packages, they either do too much or not enough. Chalk is a clean and focused alternative.
+
+
 ## Related
 
 - [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module
 - [ansi-styles](https://github.com/chalk/ansi-styles) - ANSI escape codes for styling strings in the terminal
 - [supports-color](https://github.com/chalk/supports-color) - Detect whether a terminal supports color
 - [strip-ansi](https://github.com/chalk/strip-ansi) - Strip ANSI escape codes
+- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Strip ANSI escape codes from a stream
 - [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
 - [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
 - [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes
 - [slice-ansi](https://github.com/chalk/slice-ansi) - Slice a string with ANSI escape codes
 - [color-convert](https://github.com/qix-/color-convert) - Converts colors between different models
+- [chalk-animation](https://github.com/bokub/chalk-animation) - Animate strings in the terminal
+- [gradient-string](https://github.com/bokub/gradient-string) - Apply color gradients to strings
+- [chalk-pipe](https://github.com/LitoMore/chalk-pipe) - Create chalk style schemes with simpler style strings
 
 
 ## Maintainers

package/templates.js

@@ -1,175 +1,128 @@
 'use strict';
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+
+const ESCAPES = new Map([
+	['n', '\n'],
+	['r', '\r'],
+	['t', '\t'],
+	['b', '\b'],
+	['f', '\f'],
+	['v', '\v'],
+	['0', '\0'],
+	['\\', '\\'],
+	['e', '\u001B'],
+	['a', '\u0007']
+]);
+
+function unescape(c) {
+	if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+		return String.fromCharCode(parseInt(c.slice(1), 16));
+	}
 
-function data(parent) {
-	return {
-		styles: [],
-		parent,
-		contents: []
-	};
+	return ESCAPES.get(c) || c;
 }
 
-const zeroBound = n => n < 0 ? 0 : n;
-const lastIndex = a => zeroBound(a.length - 1);
-
-const last = a => a[lastIndex(a)];
-
-const takeWhileReverse = (array, predicate, start) => {
-	const out = [];
+function parseArguments(name, args) {
+	const results = [];
+	const chunks = args.trim().split(/\s*,\s*/g);
+	let matches;
 
-	for (let i = start; i >= 0 && i <= start; i--) {
-		if (predicate(array[i])) {
-			out.unshift(array[i]);
+	for (const chunk of chunks) {
+		if (!isNaN(chunk)) {
+			results.push(Number(chunk));
+		} else if ((matches = chunk.match(STRING_REGEX))) {
+			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
 		} else {
-			break;
+			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
 		}
 	}
 
-	return out;
-};
-
-/**
- * Checks if the character at position i in string is a normal character a.k.a a non control character.
- * */
-const isNormalCharacter = (string, i) => {
-	const char = string[i];
-	const backslash = '\\';
-
-	if (!(char === backslash || char === '{' || char === '}')) {
-		return true;
-	}
+	return results;
+}
 
-	const n = i === 0 ? 0 : takeWhileReverse(string, x => x === '\\', zeroBound(i - 1)).length;
+function parseStyle(style) {
+	STYLE_REGEX.lastIndex = 0;
 
-	return n % 2 === 1;
-};
+	const results = [];
+	let matches;
 
-const collectStyles = data => data ? collectStyles(data.parent).concat(data.styles) : ['reset'];
+	while ((matches = STYLE_REGEX.exec(style)) !== null) {
+		const name = matches[1];
 
-/**
- * Computes the style for a given data based on it's style and the style of it's parent. Also accounts for !style styles
- * which remove a style from the list if present.
- * */
-const sumStyles = data => {
-	const negateRegex = /^~.+/;
-	let out = [];
-
-	for (const style of collectStyles(data)) {
-		if (negateRegex.test(style)) {
-			const exclude = style.slice(1);
-			out = out.filter(x => x !== exclude);
+		if (matches[2]) {
+			const args = parseArguments(name, matches[2]);
+			results.push([name].concat(args));
 		} else {
-			out.push(style);
+			results.push([name]);
 		}
 	}
 
-	return out;
-};
-
-/**
- * Takes a string and parses it into a tree of data objects which inherit styles from their parent.
- * */
-function parse(string) {
-	const root = data(null);
-	let pushingStyle = false;
-
-	let current = root;
+	return results;
+}
 
-	for (let i = 0; i < string.length; i++) {
-		const char = string[i];
+function buildStyle(chalk, styles) {
+	const enabled = {};
 
-		const addNormalCharacter = () => {
-			const lastChunk = last(current.contents);
+	for (const layer of styles) {
+		for (const style of layer.styles) {
+			enabled[style[0]] = layer.inverse ? null : style.slice(1);
+		}
+	}
 
-			if (typeof lastChunk === 'string') {
-				current.contents[lastIndex(current.contents)] = lastChunk + char;
-			} else {
-				current.contents.push(char);
+	let current = chalk;
+	for (const styleName of Object.keys(enabled)) {
+		if (Array.isArray(enabled[styleName])) {
+			if (!(styleName in current)) {
+				throw new Error(`Unknown Chalk style: ${styleName}`);
 			}
-		};
-
-		if (pushingStyle) {
-			if (' \t'.indexOf(char) > -1) {
-				pushingStyle = false;
-			} else if (char === '\n') {
-				pushingStyle = false;
-				addNormalCharacter();
-			} else if (char === '.') {
-				current.styles.push('');
+
+			if (enabled[styleName].length > 0) {
+				current = current[styleName].apply(current, enabled[styleName]);
 			} else {
-				current.styles[lastIndex(current.styles)] = (last(current.styles) || '') + char;
+				current = current[styleName];
 			}
-		} else if (isNormalCharacter(string, i)) {
-			addNormalCharacter();
-		} else if (char === '{') {
-			pushingStyle = true;
-			const nCurrent = data(current);
-			current.contents.push(nCurrent);
-			current = nCurrent;
-		} else if (char === '}') {
-			current = current.parent;
 		}
 	}
 
-	if (current !== root) {
-		throw new Error('literal template has an unclosed block');
-	}
-
-	return root;
+	return current;
 }
 
-/**
- * Takes a tree of data objects and flattens it to a list of data objects with the inherited and negations styles
- * accounted for.
- * */
-function flatten(data) {
-	let flat = [];
-
-	for (const content of data.contents) {
-		if (typeof content === 'string') {
-			flat.push({
-				styles: sumStyles(data),
-				content
-			});
+module.exports = (chalk, tmp) => {
+	const styles = [];
+	const chunks = [];
+	let chunk = [];
+
+	// eslint-disable-next-line max-params
+	tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+		if (escapeChar) {
+			chunk.push(unescape(escapeChar));
+		} else if (style) {
+			const str = chunk.join('');
+			chunk = [];
+			chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+			styles.push({inverse, styles: parseStyle(style)});
+		} else if (close) {
+			if (styles.length === 0) {
+				throw new Error('Found extraneous } in Chalk template literal');
+			}
+
+			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+			chunk = [];
+			styles.pop();
 		} else {
-			flat = flat.concat(flatten(content));
+			chunk.push(chr);
 		}
-	}
+	});
 
-	return flat;
-}
+	chunks.push(chunk.join(''));
 
-function assertStyle(chalk, style) {
-	if (!chalk[style]) {
-		throw new Error(`invalid Chalk style: ${style}`);
+	if (styles.length > 0) {
+		const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+		throw new Error(errMsg);
 	}
-}
 
-/**
- * Checks if a given style is valid and parses style functions.
- * */
-function parseStyle(chalk, style) {
-	const fnMatch = style.match(/^\s*(\w+)\s*\(\s*([^)]*)\s*\)\s*/);
-	if (!fnMatch) {
-		assertStyle(chalk, style);
-		return chalk[style];
-	}
-
-	const name = fnMatch[1].trim();
-	const args = fnMatch[2].split(/,/g).map(s => s.trim());
-
-	assertStyle(chalk, name);
-
-	return chalk[name].apply(chalk, args);
-}
-
-/**
- * Performs the actual styling of the string, essentially lifted from cli.js.
- * */
-function style(chalk, flat) {
-	return flat.map(data => {
-		const fn = data.styles.reduce(parseStyle, chalk);
-		return fn(data.content.replace(/\n$/, ''));
-	}).join('');
-}
-
-module.exports = (chalk, string) => style(chalk, flatten(parse(string)));
+	return chunks.join('');
+};

package/types/index.d.ts

@@ -0,0 +1,97 @@
+// Type definitions for Chalk
+// Definitions by: Thomas Sauer <https://github.com/t-sauer>
+
+export const enum Level {
+	None = 0,
+	Basic = 1,
+	Ansi256 = 2,
+	TrueColor = 3
+}
+
+export interface ChalkOptions {
+	enabled?: boolean;
+	level?: Level;
+}
+
+export interface ChalkConstructor {
+	new (options?: ChalkOptions): Chalk;
+	(options?: ChalkOptions): Chalk;
+}
+
+export interface ColorSupport {
+	level: Level;
+	hasBasic: boolean;
+	has256: boolean;
+	has16m: boolean;
+}
+
+export interface Chalk {
+	(...text: string[]): string;
+	(text: TemplateStringsArray, ...placeholders: string[]): string;
+	constructor: ChalkConstructor;
+	enabled: boolean;
+	level: Level;
+	rgb(r: number, g: number, b: number): this;
+	hsl(h: number, s: number, l: number): this;
+	hsv(h: number, s: number, v: number): this;
+	hwb(h: number, w: number, b: number): this;
+	bgHex(color: string): this;
+	bgKeyword(color: string): this;
+	bgRgb(r: number, g: number, b: number): this;
+	bgHsl(h: number, s: number, l: number): this;
+	bgHsv(h: number, s: number, v: number): this;
+	bgHwb(h: number, w: number, b: number): this;
+	hex(color: string): this;
+	keyword(color: string): this;
+
+	readonly reset: this;
+	readonly bold: this;
+	readonly dim: this;
+	readonly italic: this;
+	readonly underline: this;
+	readonly inverse: this;
+	readonly hidden: this;
+	readonly strikethrough: this;
+
+	readonly visible: this;
+
+	readonly black: this;
+	readonly red: this;
+	readonly green: this;
+	readonly yellow: this;
+	readonly blue: this;
+	readonly magenta: this;
+	readonly cyan: this;
+	readonly white: this;
+	readonly gray: this;
+	readonly grey: this;
+	readonly blackBright: this;
+	readonly redBright: this;
+	readonly greenBright: this;
+	readonly yellowBright: this;
+	readonly blueBright: this;
+	readonly magentaBright: this;
+	readonly cyanBright: this;
+	readonly whiteBright: this;
+
+	readonly bgBlack: this;
+	readonly bgRed: this;
+	readonly bgGreen: this;
+	readonly bgYellow: this;
+	readonly bgBlue: this;
+	readonly bgMagenta: this;
+	readonly bgCyan: this;
+	readonly bgWhite: this;
+	readonly bgBlackBright: this;
+	readonly bgRedBright: this;
+	readonly bgGreenBright: this;
+	readonly bgYellowBright: this;
+	readonly bgBlueBright: this;
+	readonly bgMagentaBright: this;
+	readonly bgCyanBright: this;
+	readonly bgWhiteBright: this;
+}
+
+declare const chalk: Chalk & { supportsColor: ColorSupport };
+
+export default chalk