colorette

What is colorette?

The colorette npm package is a Node.js library for colorizing text in the terminal. It provides a simple API to add colors and styles to console output, which can be useful for creating more readable and organized logs, command-line tools, and scripts.

What are colorette's main functionalities?

Text coloring

Colorette allows you to color text output in the terminal. You can use predefined color functions to wrap your text and make it appear in the specified color when logged to the console.

const { red, green, blue } = require('colorette');
console.log(red('This is red text'));
console.log(green('This is green text'));
console.log(blue('This is blue text'));

Text styling

In addition to coloring, colorette provides functions to apply various text styles such as bold, underline, and italic.

const { bold, underline, italic } = require('colorette');
console.log(bold('This is bold text'));
console.log(underline('This is underlined text'));
console.log(italic('This is italic text'));

Combining styles

Colorette allows you to combine multiple styles and colors for a single piece of text. This can be useful for highlighting important information or creating visually distinct messages in the terminal.

const { red, bold, bgGreen } = require('colorette');
console.log(bold(red(bgGreen('Red text on green background'))));

Other packages similar to colorette

chalk

Chalk is a popular npm package similar to colorette that allows for styling and coloring terminal text. It offers a chainable API and additional color options. Chalk is known for its ease of use and extensive customization capabilities, but it might be slightly larger in size compared to colorette.

ansi-colors

Ansi-colors is another npm package for coloring terminal text. It focuses on performance and is dependency-free. It provides a similar API to colorette but with a different implementation approach. Ansi-colors may offer better performance in certain scenarios.

kleur

Kleur is a lightweight alternative to colorette with zero dependencies. It offers a similar API for text coloring and formatting. Kleur is designed for performance and has a minimalistic approach, which might make it faster in some cases.

README

Colorette

Colorette is a Node.js library for colorizing text using ANSI escape sequences.

Features

• Zero dependency
• Automatic color support detection
• Toggle color output on/off as needed
• Need for speed? Colorette is the fastest terminal colorizer for Node.js

Installation

npm i colorette

Usage

Import the style functions you want to use.

const { red, blue, bold } = require("colorette")

Then use them to colorize your output.

console.log(bold(blue("Engage!")))

Mix it with template literals.

console.log(`
  Beets are ${red("red")},
  Plums are ${blue("blue")},
  ${bold("Colorette!")}.
`)

Use console.log's string substitution.

console.log(bold("Total: $%f"), 1.99)

Nest styles without breaking an existing open sequence.

console.log(red(`Red Shirt ${blue("Blue Shirt")} Red Shirt`))

Feeling adventurous? Try the pipeline operator.

console.log("Make it so!" |> bold |> blue)

API

style(string)

Every style function returns its string argument wrapped in the corresponding ANSI escape sequence.

red("Red Alert") //=> \u001b[31mRed Alert\u001b[39m

options.enabled

Color support is automatically enabled if your terminal supports it, but you can toggle it on/off as needed.

const { options } = require("colorette")

options.enabled = false

Styles

Colorette supports the normal and bright color variations.

Colors	Background Colors	Bright Colors	Bright Background Colors	Modifiers
black	bgBlack	blackBright	bgBlackBright	dim
red	bgRed	redBright	bgRedBright	bold
green	bgGreen	greenBright	bgGreenBright	hidden
yellow	bgYellow	yellowBright	bgYellowBright	italic
blue	bgBlue	blueBright	bgBlueBright	underline
magenta	bgMagenta	magentaBright	bgMagentaBright	strikethrough
cyan	bgCyan	cyanBright	bgCyanBright	reset
white	bgWhite	whiteBright	bgWhiteBright
gray

To chalk or not to chalk?

Chalk is the go-to terminal colorizer for Node.js. It's robust and actively maintained. So, why not chalk? Because we can do just as well with less. Chalk is larger than colorette and 20 to 100 times slower depending on what you're doing.

Part of the complexity comes from a chainable API where styles are used both as properties and methods by sharing the same prototype. It isn't evident how this could work unless you look at the implementation. You are just told it does, but none of it is essential to solve the problem at thand.

red.bold.underline("Do you believe in magic?")

Colorette's approach has more sticking parentheses, but it has been carved away of all the surprises.

red(bold(underline("Do you believe in magic?")))

Benchmark Results

All tests run on a 2.4GHz Intel Core i7 CPU with 16 GB memory.

npm i -C bench && node bench

# Using Styles
chalk × 8,020 ops/sec
kleur × 269,041 ops/sec
ansi-colors × 156,343 ops/sec
colorette × 692,207 ops/sec

# Combining Styles
chalk × 27,268 ops/sec
kleur × 726,598 ops/sec
ansi-colors × 252,814 ops/sec
colorette × 1,903,657 ops/sec

# Nesting Styles
chalk × 22,736 ops/sec
kleur × 281,761 ops/sec
ansi-colors × 226,470 ops/sec
colorette × 382,293 ops/sec

License

Colorette is MIT licensed. See LICENSE.