Merge branch 'master' into remove-blue-workaround

chalk · Mar 12, 2019 · 077329e · 077329e
2 parents b5cd8ba + 3ef170b
commit 077329e
Show file tree

Hide file tree

Showing 15 changed files with 162 additions and 138 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -2,6 +2,5 @@ language: node_js
 node_js:
   - '10'
   - '8'
-  - '6'
 after_success:
   - './node_modules/.bin/nyc report --reporter=text-lcov | ./node_modules/.bin/coveralls'
diff --git a/examples/rainbow.js b/examples/rainbow.js
@@ -3,36 +3,39 @@ const chalk = require('..');
 
 const ignoreChars = /[^!-~]/g;
 
-function rainbow(str, offset) {
-	if (!str || str.length === 0) {
-		return str;
+const delay = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds));
+
+function rainbow(string, offset) {
+	if (!string || string.length === 0) {
+		return string;
 	}
 
-	const hueStep = 360 / str.replace(ignoreChars, '').length;
+	const hueStep = 360 / string.replace(ignoreChars, '').length;
 
 	let hue = offset % 360;
-	const chars = [];
-	for (const c of str) {
-		if (c.match(ignoreChars)) {
-			chars.push(c);
+	const characters = [];
+	for (const character of string) {
+		if (character.match(ignoreChars)) {
+			characters.push(character);
 		} else {
-			chars.push(chalk.hsl(hue, 100, 50)(c));
+			characters.push(chalk.hsl(hue, 100, 50)(character));
 			hue = (hue + hueStep) % 360;
 		}
 	}
 
-	return chars.join('');
+	return characters.join('');
 }
 
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-async function animateString(str) {
+async function animateString(string) {
 	console.log();
 	for (let i = 0; i < 360 * 5; i++) {
-		console.log('\u001B[1F\u001B[G ', rainbow(str, i));
-		await sleep(2); // eslint-disable-line no-await-in-loop
+		console.log('\u001B[1F\u001B[G', rainbow(string, i));
+		await delay(2); // eslint-disable-line no-await-in-loop
 	}
 }
 
-console.log();
-animateString('We hope you enjoy the new version of Chalk 2! <3').then(() => console.log());
+(async () => {
+	console.log();
+	await animateString('We hope you enjoy Chalk! <3');
+	console.log();
+})();
diff --git a/index.d.ts b/index.d.ts
@@ -35,7 +35,7 @@ export interface Options {
 	level?: Level;
 }
 
-export interface Constructor {
+export interface Instance {
 	/**
 	 * Return a new Chalk instance.
 	 */
@@ -75,7 +75,7 @@ export interface Chalk {
 	/**
 	 * Return a new Chalk instance.
 	 */
-	constructor: Constructor;
+	Instance: Instance;
 
 	/**
 	 * Enable or disable Chalk.
@@ -271,6 +271,6 @@ export interface Chalk {
  * Order doesn't matter, and later styles take precedent in case of a conflict.
  * This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
  */
-declare const chalk: Chalk & { supportsColor: ColorSupport };
+declare const chalk: Chalk & {supportsColor: ColorSupport};
 
 export default chalk;
diff --git a/index.js b/index.js
@@ -7,7 +7,12 @@ const template = require('./templates.js');
 const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
 
 // `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m'
+];
 
 // `color-convert` models to exclude from the Chalk API due to conflicts and such
 const skipModels = new Set(['gray']);
@@ -25,33 +30,40 @@ function applyOptions(object, options = {}) {
 	object.enabled = 'enabled' in options ? options.enabled : object.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
-	if (!this || !(this instanceof Chalk) || this.template) {
-		const chalk = {};
-		applyOptions(chalk, options);
+class ChalkClass {
+	constructor(options) {
+		return chalkFactory(options);
+	}
+}
 
-		chalk.template = (...args) => chalkTag(chalk.template, ...args);
+function chalkFactory(options) {
+	const chalk = {};
+	applyOptions(chalk, options);
 
-		Object.setPrototypeOf(chalk, Chalk.prototype);
-		Object.setPrototypeOf(chalk.template, chalk);
+	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
 
-		chalk.template.constructor = Chalk;
+	Object.setPrototypeOf(chalk, Chalk.prototype);
+	Object.setPrototypeOf(chalk.template, chalk);
 
-		return chalk.template;
-	}
+	chalk.template.constructor = () => {
+		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
+	};
 
-	applyOptions(this, options);
+	chalk.template.Instance = ChalkClass;
+
+	return chalk.template;
 }
 
-for (const key of Object.keys(ansiStyles)) {
-	ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+function Chalk(options) {
+	return chalkFactory(options);
+}
 
-	styles[key] = {
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	style.closeRe = new RegExp(escapeStringRegexp(style.close), 'g');
+
+	styles[styleName] = {
 		get() {
-			const codes = ansiStyles[key];
-			return build.call(this, [...(this._styles || []), codes], this._empty, key);
+			return build.call(this, [...(this._styles || []), style], this._empty, styleName);
 		}
 	};
 }
@@ -94,8 +106,8 @@ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
 	styles[bgModel] = {
 		get() {
 			const {level} = this;
-			return function (...args) {
-				const open = ansiStyles.bgColor[levelMapping[level]][model](...args);
+			return function (...arguments_) {
+				const open = ansiStyles.bgColor[levelMapping[level]][model](...arguments_);
 				const codes = {
 					open,
 					close: ansiStyles.bgColor.close,
@@ -110,7 +122,7 @@ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
 const proto = Object.defineProperties(() => {}, styles);
 
 function build(_styles, _empty, key) {
-	const builder = (...args) => applyStyle.call(builder, ...args);
+	const builder = (...arguments_) => applyStyle.call(builder, ...arguments_);
 	builder._styles = _styles;
 	builder._empty = _empty;
 
@@ -146,8 +158,8 @@ function build(_styles, _empty, key) {
 	return builder;
 }
 
-function applyStyle(...args) {
-	let string = args.join(' ');
+function applyStyle(...arguments_) {
+	let string = arguments_.join(' ');
 
 	if (!this.enabled || this.level <= 0 || !string) {
 		return this._empty ? '' : string;
@@ -188,12 +200,12 @@ function chalkTag(chalk, ...strings) {
 		return strings.join(' ');
 	}
 
-	const args = strings.slice(1);
+	const arguments_ = strings.slice(1);
 	const parts = [firstString.raw[0]];
 
 	for (let i = 1; i < firstString.length; i++) {
 		parts.push(
-			String(args[i - 1]).replace(/[{}\\]/g, '\\$&'),
+			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
 			String(firstString.raw[i])
 		);
 	}

diff --git a/index.js.flow b/index.js.flow
@@ -24,7 +24,7 @@ export type ColorSupport = {|
 export interface Chalk {
 	(...text: string[]): string,
 	(text: TemplateStringsArray, ...placeholders: mixed[]): string,
-	constructor(options?: Options): Chalk,
+	Instance(options?: Options): Chalk,
 	enabled: boolean,
 	level: Level,
 	rgb(red: number, green: number, blue: number): Chalk,

diff --git a/index.test-d.ts b/index.test-d.ts
@@ -16,8 +16,8 @@ expectType<boolean>(chalk.supportsColor.has256);
 expectType<boolean>(chalk.supportsColor.has16m);
 
 // - Chalk -
-// -- Constructor --
-expectType<Chalk>(new chalk.constructor({level: 1}));
+// -- Instance --
+expectType<Chalk>(new chalk.Instance({level: 1}));
 
 // -- Properties --
 expectType<boolean>(chalk.enabled);

diff --git a/package.json b/package.json
@@ -5,7 +5,7 @@
 	"license": "MIT",
 	"repository": "chalk/chalk",
 	"engines": {
-		"node": ">=6"
+		"node": ">=8"
 	},
 	"scripts": {
 		"test": "xo && nyc ava && tsd-check && flow",
@@ -43,20 +43,20 @@
 	"dependencies": {
 		"ansi-styles": "^3.2.1",
 		"escape-string-regexp": "^1.0.5",
-		"supports-color": "^6.0.0"
+		"supports-color": "^6.1.0"
 	},
 	"devDependencies": {
-		"@sindresorhus/tsconfig": "^0.1.1",
-		"ava": "^1.0.1",
-		"coveralls": "^3.0.2",
+		"@sindresorhus/tsconfig": "^0.2.1",
+		"ava": "^1.3.1",
+		"coveralls": "^3.0.3",
 		"execa": "^1.0.0",
-		"flow-bin": "^0.89.0",
+		"flow-bin": "^0.94.0",
 		"import-fresh": "^3.0.0",
 		"matcha": "^0.7.0",
-		"nyc": "^13.1.0",
+		"nyc": "^13.3.0",
 		"resolve-from": "^4.0.0",
 		"tsd-check": "^0.3.0",
-		"xo": "^0.23.0"
+		"xo": "^0.24.0"
 	},
 	"types": "index.d.ts",
 	"xo": {

diff --git a/readme.md b/readme.md
@@ -140,12 +140,12 @@ Multiple arguments will be separated by space.
 
 Color support is automatically detected, as is the level (see `chalk.level`). However, if you'd like to simply enable/disable Chalk, you can do so via the `.enabled` property. When `chalk.enabled` is `true`, `chalk.level` must *also* be greater than `0` for colored output to be produced.
 
-Chalk is enabled by default unless explicitly disabled via the constructor or `chalk.level` is `0`.
+Chalk is enabled by default unless explicitly disabled via `new chalk.Instance()` or `chalk.level` is `0`.
 
 If you need to change this in a reusable module, create a new instance:
 
 ```js
-const ctx = new chalk.constructor({enabled: false});
+const ctx = new chalk.Instance({enabled: false});
 ```
 
 ### chalk.level
@@ -155,7 +155,7 @@ Color support is automatically detected, but you can override it by setting the
 If you need to change this in a reusable module, create a new instance:
 
 ```js
-const ctx = new chalk.constructor({level: 0});
+const ctx = new chalk.Instance({level: 0});
 ```
 
 Levels are as follows:

diff --git a/templates.js b/templates.js
@@ -25,9 +25,9 @@ function unescape(c) {
 	return ESCAPES.get(c) || c;
 }
 
-function parseArguments(name, args) {
+function parseArguments(name, arguments_) {
 	const results = [];
-	const chunks = args.trim().split(/\s*,\s*/g);
+	const chunks = arguments_.trim().split(/\s*,\s*/g);
 	let matches;
 
 	for (const chunk of chunks) {
@@ -51,7 +51,7 @@ function parseStyle(style) {
 	let matches;
 
 	while ((matches = STYLE_REGEX.exec(style)) !== null) {
-		const name = matches[1]; // eslint-disable-line prefer-destructuring
+		const name = matches[1];
 
 		if (matches[2]) {
 			const args = parseArguments(name, matches[2]);
@@ -74,33 +74,28 @@ function buildStyle(chalk, styles) {
 	}
 
 	let current = chalk;
-	// TODO: Use `Object.entries` when targeting Node.js 8
-	for (const styleName of Object.keys(enabled)) {
-		if (!Array.isArray(enabled[styleName])) {
+	for (const [styleName, styles] of Object.entries(enabled)) {
+		if (!Array.isArray(styles)) {
 			continue;
 		}
 
 		if (!(styleName in current)) {
 			throw new Error(`Unknown Chalk style: ${styleName}`);
 		}
 
-		if (enabled[styleName].length > 0) {
-			current = current[styleName](...enabled[styleName]);
-		} else {
-			current = current[styleName];
-		}
+		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
 	}
 
 	return current;
 }
 
-module.exports = (chalk, tmp) => {
+module.exports = (chalk, temporary) => {
 	const styles = [];
 	const chunks = [];
 	let chunk = [];
 
 	// eslint-disable-next-line max-params
-	tmp.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+	temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
 		if (escapeCharacter) {
 			chunk.push(unescape(escapeCharacter));
 		} else if (style) {

diff --git a/test/_flow.js b/test/_flow.js
@@ -2,12 +2,12 @@
 import chalk from '..';
 
 // $ExpectError (Can't have typo in option name)
-chalk.constructor({levl: 1});
-chalk.constructor({level: 1});
+new chalk.Instance({levl: 1});
+new chalk.Instance({level: 1});
 
 // $ExpectError (Option must have proper type)
-new chalk.constructor({enabled: 'true'});
-new chalk.constructor({enabled: true});
+new chalk.Instance({enabled: 'true'});
+new chalk.Instance({enabled: true});
 
 // $ExpectError (Can't have typo in chalk method)
 chalk.rd('foo');
@@ -22,8 +22,8 @@ chalk.red.bgBlu.underline('foo');
 chalk.red.bgBlue.underline('foo');
 
 // $ExpectError (Level must be 0, 1, 2, or 3)
-const badCtx = chalk.constructor({level: 4});
-const ctx = chalk.constructor({level: 3});
+const badCtx = chalk.Instance({level: 4});
+const ctx = chalk.Instance({level: 3});
 
 // $ExpectError (Can't have typo in method name)
 ctx.gry('foo');
@@ -41,7 +41,7 @@ chalk.enabled = true;
 chalk.level = 10;
 chalk.level = 1;
 
-const chalkInstance = new chalk.constructor();
+const chalkInstance = new chalk.Instance();
 
 // $ExpectError (Can't have typo in method name)
 chalkInstance.blu('foo');