'use strict';
|
const ansiStyles = require('ansi-styles');
|
const {stdout: stdoutColor, stderr: stderrColor} = require('supports-color');
|
const {
|
stringReplaceAll,
|
stringEncaseCRLFWithFirstIndex
|
} = require('./util');
|
|
const {isArray} = Array;
|
|
// `supportsColor.level` → `ansiStyles.color[name]` mapping
|
const levelMapping = [
|
'ansi',
|
'ansi',
|
'ansi256',
|
'ansi16m'
|
];
|
|
const styles = Object.create(null);
|
|
const applyOptions = (object, options = {}) => {
|
if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
|
throw new Error('The `level` option should be an integer from 0 to 3');
|
}
|
|
// Detect level if not set manually
|
const colorLevel = stdoutColor ? stdoutColor.level : 0;
|
object.level = options.level === undefined ? colorLevel : options.level;
|
};
|
|
class ChalkClass {
|
constructor(options) {
|
// eslint-disable-next-line no-constructor-return
|
return chalkFactory(options);
|
}
|
}
|
|
const chalkFactory = options => {
|
const chalk = {};
|
applyOptions(chalk, options);
|
|
chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
|
|
Object.setPrototypeOf(chalk, Chalk.prototype);
|
Object.setPrototypeOf(chalk.template, chalk);
|
|
chalk.template.constructor = () => {
|
throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
|
};
|
|
chalk.template.Instance = ChalkClass;
|
|
return chalk.template;
|
};
|
|
function Chalk(options) {
|
return chalkFactory(options);
|
}
|
|
for (const [styleName, style] of Object.entries(ansiStyles)) {
|
styles[styleName] = {
|
get() {
|
const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
|
Object.defineProperty(this, styleName, {value: builder});
|
return builder;
|
}
|
};
|
}
|
|
styles.visible = {
|
get() {
|
const builder = createBuilder(this, this._styler, true);
|
Object.defineProperty(this, 'visible', {value: builder});
|
return builder;
|
}
|
};
|
|
const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
|
|
for (const model of usedModels) {
|
styles[model] = {
|
get() {
|
const {level} = this;
|
return function (...arguments_) {
|
const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
|
return createBuilder(this, styler, this._isEmpty);
|
};
|
}
|
};
|
}
|
|
for (const model of usedModels) {
|
const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
|
styles[bgModel] = {
|
get() {
|
const {level} = this;
|
return function (...arguments_) {
|
const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
|
return createBuilder(this, styler, this._isEmpty);
|
};
|
}
|
};
|
}
|
|
const proto = Object.defineProperties(() => {}, {
|
...styles,
|
level: {
|
enumerable: true,
|
get() {
|
return this._generator.level;
|
},
|
set(level) {
|
this._generator.level = level;
|
}
|
}
|
});
|
|
const createStyler = (open, close, parent) => {
|
let openAll;
|
let closeAll;
|
if (parent === undefined) {
|
openAll = open;
|
closeAll = close;
|
} else {
|
openAll = parent.openAll + open;
|
closeAll = close + parent.closeAll;
|
}
|
|
return {
|
open,
|
close,
|
openAll,
|
closeAll,
|
parent
|
};
|
};
|
|
const createBuilder = (self, _styler, _isEmpty) => {
|
const builder = (...arguments_) => {
|
if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
|
// Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
|
return applyStyle(builder, chalkTag(builder, ...arguments_));
|
}
|
|
// Single argument is hot path, implicit coercion is faster than anything
|
// eslint-disable-next-line no-implicit-coercion
|
return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
|
};
|
|
// We alter the prototype because we must return a function, but there is
|
// no way to create a function with a different prototype
|
Object.setPrototypeOf(builder, proto);
|
|
builder._generator = self;
|
builder._styler = _styler;
|
builder._isEmpty = _isEmpty;
|
|
return builder;
|
};
|
|
const applyStyle = (self, string) => {
|
if (self.level <= 0 || !string) {
|
return self._isEmpty ? '' : string;
|
}
|
|
let styler = self._styler;
|
|
if (styler === undefined) {
|
return string;
|
}
|
|
const {openAll, closeAll} = styler;
|
if (string.indexOf('\u001B') !== -1) {
|
while (styler !== undefined) {
|
// Replace any instances already present with a re-opening code
|
// otherwise only the part of the string until said closing code
|
// will be colored, and the rest will simply be 'plain'.
|
string = stringReplaceAll(string, styler.close, styler.open);
|
|
styler = styler.parent;
|
}
|
}
|
|
// We can move both next actions out of loop, because remaining actions in loop won't have
|
// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
|
// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
|
const lfIndex = string.indexOf('\n');
|
if (lfIndex !== -1) {
|
string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
|
}
|
|
return openAll + string + closeAll;
|
};
|
|
let template;
|
const chalkTag = (chalk, ...strings) => {
|
const [firstString] = strings;
|
|
if (!isArray(firstString) || !isArray(firstString.raw)) {
|
// If chalk() was called by itself or with a string,
|
// return the string itself as a string.
|
return strings.join(' ');
|
}
|
|
const arguments_ = strings.slice(1);
|
const parts = [firstString.raw[0]];
|
|
for (let i = 1; i < firstString.length; i++) {
|
parts.push(
|
String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
|
String(firstString.raw[i])
|
);
|
}
|
|
if (template === undefined) {
|
template = require('./templates');
|
}
|
|
return template(chalk, parts.join(''));
|
};
|
|
Object.defineProperties(Chalk.prototype, styles);
|
|
const chalk = Chalk(); // eslint-disable-line new-cap
|
chalk.supportsColor = stdoutColor;
|
chalk.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
|
chalk.stderr.supportsColor = stderrColor;
|
|
module.exports = chalk;
|
