Descarga de ansis - Descargar el código fuente ansis

Estilos de ansi

Una biblioteca de nodo.js pequeña y rápida para aplicar colores y estilos de ANSI en la salida terminal.
ANSIS proporciona todas las características que necesita, puede comparar con bibliotecas similares.
ANSIS es más rápida que la tiza y los picocoloros (en algunos casos de uso), ver puntos de referencia.

Instalar y iniciar rápidamente por qué cambiar a ANSIS

Uso

 import ansis , { red , green , cyan , black , ansi256 , hex } from 'ansis' ;

ansis . blueBright ( 'file.txt' )
green `Succeful!`
red `Error: ${ cyan ( file ) } not found!`
black . bgYellow `Warning!`
ansi256 ( 214 ) `Orange`
hex ( '#E0115F' ) . bold . underline ( 'Truecolor!' )

⚖️ Bibliotecas similares

Las bibliotecas Node.js más populares similares a ANSIS:

Tiza, Picocolors, Colorette, Kleur, Ansi-Colors, Kolorist, Cli-Color, Colors-Cli, Colors.js

✅ Comparar características? Compare los puntos de referencia de los tamaños de paquetes

Reflejos

Admite ESM , CommonJS , TypeScript
Apoya a Bun , Deno , Next.js Runtimes
Reemplazo de recolección picocolors colorette chalk ansi-colors
Predeterminado y nombrado importación import ansis, { red, bold, ansi256, hex } from 'ansis'
Sintaxis encadenada red.bold.underline('text')
Strings de plantilla anidada red`Error: ${blue`file.js`} not found!`
Estilos ~~strikethrough~~ underline dim italic bold
ANSI 16 Colors red`Error!` redBright`Error!` bgRed`Error!` bgRedBright`Error!`
ANSI 256 Colors fg(56)`violet` bg(208)`orange`
Truecolor ( RGB , Hex ) rgb(224, 17, 95)`Ruby` hex('#96C')`Amethyst`
Espacio de color de respaldo a soporte: TrueColor → 256 Colors → 16 Colors → Sin colores
Extender los colores base con el llamado TrueColor
Códigos ANSI brutos como propiedades open y close `foo ${red.open}red{red.close} bar`
Spare el método de códigos ANSI ansis.strip()
Detecta automáticamente el soporte de color en una amplia gama de entornos
Admite variables de entorno NO_COLOR FORCE_COLOR and Flags --no-color --color
Establezca variable de colorterm para probar aplicaciones con 16, 256 o color verdadero
Ruptura de estilo correcta al end of line cuando se usa n en la cadena
No extiende String.prototype
Cero dependencias
Cobertura de prueba 100%. Mantenimiento a largo plazo.

? Utilizado por

Nestjs, Facebook/Stylex, Sequelize, Salesforce, OCLIF, WebpackBar

Solicitud / Solicitud / error

Si ha descubierto un error o tiene una sugerencia de características, no dude en crear un problema en GitHub.

Por qué cambiar a ANSIS

Hoy, las dos bibliotecas más pequeñas y más rápidas son ansis y picocolors . Ambos son recomendados por la comunidad ES Tooling como los mejores reemplazos para bibliotecas más antiguas y voluminosas.

? Tamaño desempaquetado

picocolors : 6.4 KB: una micro biblioteca con solo características básicas.
аnsis : 7.4 KB: una poderosa biblioteca que contiene todas las características que necesita.
chalk : 44.2 kb: proporciona una funcionalidad similar a ANSIS pero es más grande.

⚡ Rendimiento

picocolors : el más rápido al aplicar un solo estilo (por ejemplo, solo red ).
аnsis : el más rápido cuando se aplica dos o más estilos (por ejemplo, red + bgWhite ).
chalk : más lento que las ANSI y los picocólulos en todos los casos de uso.

? Mantenimiento

Solo se mantienen activamente ansis , chalk y picocolors , a diferencia de muchas otras bibliotecas:

colorette : Última actualización hace 2 años
ansi-colors : Último actualizado hace 3 años
kleur : la última actualizada hace 2 años
cli-color : Última actualización ~ hace 1 año
colors-cli : Último actualizado hace 1 año
colors.js : Último actualizado hace 5 años

? ¿Cuál deberías usar?

Si solo usa un solo estilo, como red('foo') , los picocolors son la mejor solución.
Sin embargo, si necesita más, como combinar múltiples estilos (por ejemplo, red + bold + bgWhite ),
ANSI256 Colors, Truecolor o Support para una amplia gama de entornos, entonces ANSIS es la mejor opción.

Explore la lista de características, tamaños de paquetes y puntos de referencia en comparación con bibliotecas similares.

Consejo

Use la sintaxis encadenada proporcionada por bibliotecas como ansis y chalk .
Evite las llamadas anidadas, ya que son mucho más lentas y menos legibles que la sintaxis encadenada.
¡Mantenga su código limpio y legible!

 red . bold . bgWhite `Error`                    ✅ ansis: faster , shorter , readable
pico . red ( pico . bold ( pico . bgWhite ( 'Error' ) ) )  picocolor: slower , longer , unreadable

red `Error: ${ cyan . underline ( file ) } not found!`                   ✅ ansis ?
pico . red ( `Error: ${ pico . cyan ( pico . underline ( file ) ) } not found!` )  picocolor ?

Cómo cambiar a ANSIS

Reemplazo de chalk
Reemplazo colorette
Reemplazo de picocolors
Reemplazo de ansi-colors
Reemplazo kleur
Reemplazo de cli-color

↑ Top

Instalar y arrancar rápido

npm install ansis

Puede importar el módulo predeterminado o los colores con nombre con ESM o sintaxis CommonJS.

 // ESM default import
import ansis from 'ansis' ;
// ESM named import
import { red , green , blue } from 'ansis' ;

 // CommonJS default import
const ansis = require ( 'ansis' ) ;
// CommonJS named import
const { red , green , blue } = require ( 'ansis' ) ;

Vea la lista de los colores y estilos de ANSI.

 console . log ( ansis . green ( 'Success!' ) ) ;
console . log ( green ( 'Success!' ) ) ;

// template string
console . log ( green `Success!` ) ;

// chained syntax
console . log ( green . bold `Success!` ) ;

// nested syntax
console . log ( red `The ${ blue . underline `file.js` } not found!` ) ;

Ejemplo básico Hello World! :

 import { red , black , inverse , reset } from 'ansis' ;

console . log ( green `Hello ${ inverse `ANSI` } World!
${ black . bgYellow `Warning:` } ${ cyan `/path/to/file.js` } ${ red `not found!` } ` ) ;

Producción:
Captura de pantalla "¡Hola Mundo Ansi!"

↑ Top

Nombrado importación

El ansis admite tanto la default import como named import .

 // default import
import ansis from 'ansis' ;

ansis . red . bold ( 'text' ) ;

Puede importar colores, estilos y funciones con nombre. Todos los colores y estilos importados son chainable .

 // named import
import { red , hex , italic } from 'ansis' ;

red . bold ( 'text' ) ;

La importación predeterminada y la importación nombrada se pueden combinar.

 // default and named import
import ansis , { red } from 'ansis' ;

const redText = red ( 'text' ) ; // colorized ANSI string
const text = ansis . strip ( redText ) ; // pure string without ANSI codes

Literales de plantilla

El ansis admite la función sintaxis red('error') y plantilla literales red`error` .

Los template literals le permiten hacer que una plantilla compleja sea más legible y más corta.
La function syntax se puede usar para colorear una variable.

 import { red } from 'ansis' ;

let message = 'error' ;

red ( message ) ;
red `text` ;
red `text ${ message } text` ;

Sintaxis encadenada

Todos los colores, estilos y funciones son encadenables. Cada color o estilo se puede combinar en cualquier orden.

 import { red , bold , italic , hex } from 'ansis' ;

red . bold `text` ;
hex ( '#FF75D1' ) . bgCyan . bold `text` ;
bold . bgHex ( '#FF75D1' ) . cyan `text` ;
italic . bold . yellow . bgMagentaBright `text` ;

↑ Top

Sintaxis anidada

Puede anidar las funciones y las cuerdas de plantilla entre sí. Ninguna de las otras bibliotecas (tiza, kleur, colorette, colores.js, etc.) admite cuerdas de plantilla anidada.

Cuerdas de plantilla anidada:

 import { red , green } from 'ansis' ;

red `red ${ green `green` } red` ;

Estilos encadenados anidados profundos:

 import { red , green , cyan , magenta , yellow , italic , underline } from 'ansis' ;

red ( `red ${ italic ( `red italic ${ underline ( `red italic underline` ) } ` ) } red` ) ;

// deep nested chained styles
green (
  `green ${ yellow (
    `yellow ${ magenta (
      `magenta ${ cyan (
        `cyan ${ red . italic . underline `red italic underline` } cyan` ,
      ) } magenta` ,
    ) } yellow` ,
  ) } green` ,
) ;

Producción:
estilos anidados de captura de pantalla

Cadenas de plantillas anidadas múltiples:

 import { red , green , hex , visible , inverse } from 'ansis' ;

// defined a Truecolor as the constant
const orange = hex ( '#FFAB40' ) ;

let cpu = 33 ;
let ram = 44 ;
let disk = 55 ;

// normal colors
visible `
CPU:  ${ red ` ${ cpu } %` }
RAM:  ${ green ` ${ ram } %` }
DISK: ${ orange ` ${ disk } %` }
` ;

// inversed colors
inverse `
CPU:  ${ red ` ${ cpu } %` }
RAM:  ${ green ` ${ ram } %` }
DISK: ${ orange ` ${ disk } %` }
` ;

Producción:
captura de pantalla múltiple anidada

↑ Top

Base Ansi 16 colores y estilos

Los colores y los estilos tienen nombres estándar utilizados por muchas bibliotecas populares, como tiza, colorette, picocolors, kleur.

Colores de primer plano	Colores de fondo	Estilos
`black`	`bgBlack`	`dim`
`red`	`bgRed`	`bold`
`green`	`bgGreen`	`italic`
`yellow`	`bgYellow`	`underline`
`blue`	`bgBlue`	~~`strikethrough`~~ (alias `strike` )
`magenta`	`bgMagenta`	`inverse`
`cyan`	`bgCyan`	`visible`
`white`	`bgWhite`	`hidden`
`blackBright` alias: `grey` ortografía `gray` estadounidense	`bgBlackBright` alias: `bgGrey` `bgGray` Us ortografía	`reset`
`redBright`	`bgRedBright`
`greenBright`	`bgGreenBright`
`yellowBright`	`bgYellowBright`
`blueBright`	`bgBlueBright`
`magentaBright`	`bgMagentaBright`
`cyanBright`	`bgCyanBright`
`whiteBright`	`bgWhiteBright`

Extender los colores base

Valores predeterminados, la instancia ansis importada contiene estilos base y colores. Para extender los colores base con nombres de color personalizados para TrueColor, use el método ansis.extend() .

 import ansis from 'ansis' ;

// extend base colors
ansis . extend ( {
  pink : '#FF75D1' ,
  orange : '#FFAB40' ,
} ) ;

// the custom colors are available under namespace `ansis`
ansis . pink ( 'text' ) ;
ansis . orange ( 'text' ) ;

Ejemplo de uso con TypeScript:

 import ansis , { AnsiColorsExtend } from 'ansis' ;

// extend base colors
ansis . extend ( {
  pink : '#FF75D1' ,
  orange : '#FFAB40' ,
} ) ;

const write = ( style : AnsiColorsExtend < 'pink' | 'orange' > , message : string ) => {
  console . log ( ansis [ style ] ( message ) ) ;
}

write ( 'red' , 'message' ) ; // base color OK
write ( 'pink' , 'message' ) ; // extended color OK
write ( 'orange' , 'message' ) ; // extended color OK
write ( 'unknown' , 'message' ) ; // TypeScript Error

↑ Top

ANSI 256 colores

El conjunto predefinido de 256 colores.

Rango de código	Descripción
0 - 7	colores estándar
8 - 15	colores brillantes
16 - 231	Cubo 6 × 6 × 6 (216 colores)
232 - 255	escala de grises de negro a blanco en 24 pasos

Función de primer plano: ansi256(code) tiene alias corta fg(code)
Función de fondo: bgAnsi256(code) tiene alias breves bg(code)

Los métodos ansi256() y bgAnsi256() se implementan para compatibilidad con la API chalk .

Ver códigos de color ANSI.

Retroceder

Si un terminal admite solo 16 colores, entonces ANSI 256 colores se interpolarán en 16 colores base.

Ejemplo de uso

 import { bold , ansi256 , fg , bgAnsi256 , bg } from 'ansis' ;

// foreground color
ansi256 ( 96 ) `Bright Cyan` ;
fg ( 96 ) `Bright Cyan` ; // alias for ansi256

// background color
bgAnsi256 ( 105 ) `Bright Magenta` ;
bg ( 105 ) `Bright Magenta` ; // alias for bgAnsi256

// function is chainable
ansi256 ( 96 ) . bold `bold Bright Cyan` ;

// function is avaliable in each style
bold . ansi256 ( 96 ) . underline `bold underline Bright Cyan` ;

// you can combine the functions and styles in any order
bgAnsi256 ( 105 ) . ansi256 ( 96 ) `cyan text on magenta background`
bg ( 105 ) . fg ( 96 ) `cyan text on magenta background`

Truecolor

Puedes usar el formato hex o rgb .

Función de primer plano: hex() rgb()
Función de fondo: bgHex() bgRgb()

 import { bold , hex , rgb , bgHex , bgRgb } from 'ansis' ;

// foreground color
hex ( '#E0115F' ) . bold `bold Ruby` ;
hex ( '#96C' ) `Amethyst` ;
rgb ( 224 , 17 , 95 ) . italic `italic Ruby` ;

// background color
bgHex ( '#E0115F' ) `Ruby` ;
bgHex ( '#96C' ) `Amethyst` ;
bgRgb ( 224 , 17 , 95 ) `Ruby` ;

// you can combine the functions and styles in any order
bold . hex ( '#E0115F' ) . bgHex ( '#96C' ) `ruby bold text on amethyst background`

↑ Top

Retroceder

El ansis admite el respaldo del espacio de color de respaldo.

 Truecolor —> 256 colors —> 16 colors —> no colors (black & white)

Si usa las funciones hex() , rgb() o ansis256() en un truecolor no compatible o 256 colores, entonces los colores se interpolarán.

output

↑ Top

Usar códigos ANSI

Puede usar los códigos de escape ANSI con propiedades open y close para cada estilo.

 import { red , bold } from 'ansis' ;

// each style has `open` and `close` properties
console . log ( `Hello ${ red . open } ANSI ${ red . close } World!` ) ;

// you can defiene own style which will have the `open` and `close` properties
const myStyle = bold . italic . black . bgHex ( '#E0115F' ) ;

console . log ( `Hello ${ myStyle . open } ANSI ${ myStyle . close } World!` ) ;

Códigos ANSI de despegar

La clase ANSIS contiene el método strip() para eliminar todos los códigos ANSI de la cadena.

 import ansis from 'ansis' ;

const ansiString = ansis . green `Hello World!` ;
const string = ansis . strip ( ansiString ) ;

La string variable contendrá la cadena pura sin códigos ANSI.

↑ Top

Nuevas líneas

Admite la ruptura de estilo correcta al end of line .

 import { bgGreen } from 'ansis' ;

console . log ( bgGreen `nAnsisnNew LinenNext New Linen` ) ;

output

Atajos / temas

Defina sus propios temas:

 import ansis from 'ansis' ;

const theme = {
  info : ansis . cyan . italic ,
  warn : ansis . black . bgYellowBright ,
  error : ansis . red . bold ,
  ruby : ansis . hex ( '#E0115F' ) ,
} ;

theme . info ( 'info' ) ;
theme . warn ( 'warning' ) ;
theme . error ( 'error' ) ;
theme . ruby ( 'Ruby color' ) ;

↑ Top

Variables de entorno CLI

Valores predeterminados, la salida en la consola terminal está coloreada y la salida en un archivo no está colorada.

Para forzar, deshabilitar o habilitar la salida de color, utilice las variables de entorno NO_COLOR y FORCE_COLOR .

La variable NO_COLOR debe ser presente con cualquier valor no vacío. El valor no es importante, por ejemplo, NO_COLOR=1 NO_COLOR=true .
Ver Descripción estándar de NO_Color.

La variable FORCE_COLOR debe presentarse con uno de valores:
FORCE_COLOR=0 Force Deshabilit Colors
FORCE_COLOR=1 Force Habilitar colores
Ver Descripción estándar de Force_Color.

Por ejemplo, App.js :

 import { red } from 'ansis' ;

console . log ( red `red color` ) ;

Ejecutar el script en un terminal:

 $ node app.js           # colored output in terminal
$ node app.js > log.txt # output in file without ANSI codes

$ NO_COLOR=1 node app.js              # force disable colors, non colored output in terminal
$ FORCE_COLOR=0 node app.js           # force disable colors, non colored output in terminal
$ FORCE_COLOR=1 node app.js > log.txt # force enable colors, output in file with ANSI codes

Usando `COLORTERM`

La variable de entorno COLORTERM es utilizada por los emuladores terminales para indicar soporte para los colores. Su valor puede variar según el emulador terminal y el nivel de soporte de color proporcionado.

Los valores comúnmente utilizados compatibles con ansis :

truecolor o 24bit - 16 millones de colores
ansi256 - ANSI 256 Colors
ansi - ANSI básico 16 colores

Puede establecer la variable en CMD antes de ejecutar el script de nodo:

 COLORTERM=truecolor node script.js # force use truecolor
COLORTERM=ansi256 node script.js   # force use 256 colors
COLORTERM=ansi node script.js      # force use 16 olors

Para establecer el nivel de color en un script, cree un archivo JS en el que defina la variable de entorno COLORTERM con el valor necesario e importe este archivo antes de ansis .

Esto puede ser útil, por ejemplo, para probar su aplicación CLI para garantizar que los resultados de la prueba sean los mismos independientemente del nivel de color compatible en diferentes entornos y terminales.

Fuerza Use Truecolor

nivel-truecolor.js

 process . env . COLORTERM = 'truecolor' ;

Su archivo de script:

 import './level-truecolor' ; // <= force use truecolor
import { red , ansi256 , hex } from 'ansis' ;

console . log ( hex ( '#FFAB40' ) ( 'orange' ) ) ; // native ANSI RGB color value
console . log ( ansi256 ( 200 ) ( 'pink' ) ) ;     // native ANSI 256 color value
console . log ( red ( 'red' ) ) ;               // native ANSI 16 color value

Fuerza usa 256 colores

nivel-256colors.js

 process . env . COLORTERM = 'ansi256' ;

Su archivo de script:

 import './level-256colors' ; // <= force use 256 colors
import { red , ansi256 , hex } from 'ansis' ;

console . log ( hex ( '#FFAB40' ) ( 'orange' ) ) ; // fallback to ANSI 256 color value
console . log ( ansi256 ( 200 ) ( 'pink' ) ) ;     // native ANSI 256 color value
console . log ( red ( 'red' ) ) ;               // native ANSI 16 color value

Fuerza Use la base de 16 colores

Nivel 16Colors.js

 process . env . COLORTERM = 'ansi' ;

Su archivo de script:

 import './level-16colors' ; // <= force use 16 olors
import { red , ansi256 , hex } from 'ansis' ;

console . log ( hex ( '#FFAB40' ) ( 'orange' ) ) ; // fallback to ANSI 16 color value - `bright red`
console . log ( ansi256 ( 200 ) ( 'pink' ) ) ;     // fallback to ANSI 16 color value - `bright magenta`
console . log ( red ( 'red' ) ) ;               // native ANSI 16 color value

↑ Top

Argumentos de CLI

Use argumentos CMD --no-color o --color=false para deshabilitar los colores y --color para habilitar los.

Por ejemplo, un script ejecutable App.js :

#!/usr/bin/env node
import { red } from 'ansis' ;

console . log ( red `red color` ) ;

Ejecutar el script en un terminal:

 $ ./app.js                        # colored output in terminal
$ ./app.js --no-color             # non colored output in terminal
$ ./app.js --color=false          # non colored output in terminal

$ ./app.js > log.txt              # output in file without ANSI codes
$ ./app.js --color > log.txt      # output in file with ANSI codes
$ ./app.js --color=true > log.txt # output in file with ANSI codes

Advertencia
Los argumentos de la línea de comandos tienen una prioridad más alta que la variable de entorno.

↑ Top

Soporte de color

ANSIS detecta automáticamente el espacio de color compatible:

Truecolor
ANSI 256 colores
ANSI 16 colores
Blanco y negro (sin colores)

ANSIS tiene el método isSupported() que devuelve un valor boolean si la salida admite el color y los estilos de ANSI.

 import ansis from 'ansis' ;

console . log ( 'Color output: ' , ansis . isSupported ( ) ) ;

No hay una forma estándar de detectar qué espacio de color es compatible. La forma más común de detectar el soporte de color es verificar las variables de entorno TERM y COLORTERM . Los sistemas CI se pueden detectar verificando la existencia del CI y otras variables específicamente de entorno. Combine eso con el conocimiento sobre qué sistema operativo se ejecuta el programa, y tenemos una forma lo suficientemente decente de detectar colores.

Terminal	ANSI 16 bandera	ANSI 256 bandera	Verdadero Color	Env. TÉRMINO	Env. COLORTERM	Específicamente variables env envadas
Azure CI	✅			mudo		Tf_build AGENT_NAME
Github CI	✅	✅	✅	mudo		CI, GitHub_actions
Gittea CI	✅	✅	✅	mudo		CI, gitea_acciones
Gitlab CI	✅			mudo		CI, gitlab_ci
Travis CI	✅			mudo		Traver
PM2 no istty	✅ ¹	✅ ¹	✅ ¹	mudo		PM2_HOME PM_ID
JetBrains Teamcity > = 2020.1.1	✅	✅				TeamCity_version
Idea de jetbrains	✅	✅	✅	xterm-256color		Terminal_emulator = 'JetBrains-Jediterm'
VS Código	✅	✅	✅	xterm-256color	truecolor
Windows Terminal	✅	✅	✅ ²
Windows Powershell	✅	✅	✅ ²
terminal de macOS	✅	✅		xterm-256color
iterm	✅	✅	✅	xterm-256color	truecolor
Gatito emulador terminal	✅	✅	✅	xterm-kitty
Emulador terminal KDE Konsole	✅	✅	✅	directo

Ver también:

Soporte de TrueColor en dispositivos de salida.
Así que desea renderizar los colores en su terminal.

↑ Top

Compare las características de las bibliotecas más populares

Ejecute el comando para ver el soporte de algunas características de varias bibliotecas:

 npm run compare

Biblioteca ________________ - Nombrado importación - Nombramientos de colores	ANSI 16 colores	ANSI 256 bandera	Verdadero Color	Encadenado sintaxis	Anificado cadenas de plantilla	Nuevo Línea	Faltback to Colors	Soporte Env vars Banderas de CLI
`ansis` `✅ named import` `✅ standard`	✅	✅	✅	✅	✅	✅	→ 256 → 16 → B & W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`chalk` `named import` `✅ standard`	✅	✅	✅	✅		✅	→ 256 → 16 → B & W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`kolorist` `✅ named import` `standard`	✅	✅	✅				→ 256 → B & W	`NO_COLOR` `FORCE_COLOR`
`cli-color` `named import` `✅ standard`	✅	✅		✅			→ 16 → B & W	`NO_COLOR`
`colors-cli` `named import` `standard`	✅	✅		✅		✅	→ B & W	`--no-color` `--color`
`colors.js` `named import` `standard`	✅			✅		✅	→ B & W	`FORCE_COLOR` `--no-color` `--color`
`ansi-colors` `named import` `✅ standard`	✅			✅		✅		`FORCE_COLOR`
`colorette` `✅ named import` `✅ standard`	✅						→ B & W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`picocolors` `named import` `✅ standard`	✅ Desde V1.1.0						→ B & W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`kleur` `✅ named import` `✅ standard`	`8` colores			✅			→ B & W	`NO_COLOR` `FORCE_COLOR`

Nota
Nombrado importación
ESM
import { red, green, blue } from 'lib';
CJS
const { red, green, blue } = require('lib');
Nombramiento de colores
Estándar: los colores tienen nombres estándar, por ejemplo: red , redBright , bgRed , bgRedBright
No estándar : los colores tienen nombres específicos de lib, por ejemplo: brightRed , bgBrightRed , red_b , red_btt
ANSI 256 colores
Los nombres de los métodos:
colors-cli : x<n>
cli-color : xterm(n)
chalk : ansi256(n) bgAnsi256(n)
ansis : ansi256(n) bgAnsi256(n) fg(n) bg(n)
Truecolor
Los nombres de los métodos:
chalk : hex() rgb()
ansis : hex() rgb()
Sintaxis encadenada
lib.red.bold('text')
Cuerdas de plantilla anidada
lib.red`text ${lib.cyan`nested`} text`
Nueva línea
Correcto estilos de descanso al end-of-line .
 lib.bgGreen(`First Line
Next Line`);

↑ Top

Compare el tamaño de los paquetes más populares

Paquete NPM	Descargar Tarball Size	Tamaño desempaquetado	Tamaño del código
`picocolors`	2.6 kb	6.4 kb	2.6 kb
`ansis`	3.8 kb	7.4 KB	3.4 KB
`colorette`	4.9 kb	17.0 kb	3.4 KB
`kleur`	6.0 kb	20.3 KB	2.7 kb
`ansi-colors`	8.5 kb	26.1 KB	5.8 kb
`kolorist`	8.7 kb	51.0 kb	6.8 kb
`colors.js`	11.0 kb	39.5 kb	18.1 KB
`chalk`	13.1 KB	43.7 kb	16.4 KB
`cli-color`	13.8 (216 kb)	39.6 (754 kb)	12.1 KB
`colors-cli`	361.7 kb	511.0 kb	8.7 kb

Tamaño de descarga: el tamaño GZipped del paquete NPM.
Tamaño desempaquetado: el tamaño del paquete NPM en el directorio node_modules/ Directory, (incl. dependencies) .
Tamaño del código : el tamaño del código distribuido que se cargará a través de require o import a su aplicación.

Ver también:

NPMJS - Mostrar tamaño de instalación del paquete publicado, dependencias
Paquete de PackagePhobia - Mostrar tamaño total de instalación, incl. dependencias
Tamaño de descarga de NPM - Mostrar tarball y tamaño de descarga total
BundlePhobia: inútil, no muestra el tamaño real del tarball del paquete NPM descargado

↑ Top

Mostrar demostración de ANSI

git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run demo

Puntos de referencia

Para medir el rendimiento se usa Benchmark.js.

Advertencia

‼ ️ No confíe en otros resultados de las pruebas utilizando Vitest Benchmark.

El vitest benchmark genera resultados falsos/ irreales .
Por ejemplo, los resultados del banco simple:

 chalk.red('foo') -  7.000.000 ops/sec
ansis.red('foo') - 23.000.000 ops/sec (x3 faster is WRONG result)

Los resultados de rendimiento reales de Chalk y ANSIS en esta prueba son muy similares.

Ejecutar puntos de referencia

git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run build
npm run bench

Probado en
MacBook Pro 16 "M1 Max 64GB
MacOS Sequoia 15.1
Node.js v22.11.0
Terminal iTerm2 v3.5.0

Nota

En las pruebas, cada biblioteca utiliza el método de estilo más rápido disponible para comparar el rendimiento absoluto de cada biblioteca.

En la práctica real, nadie usaría el método más lento (como las llamadas anidadas) para diseñar una cadena cuando la biblioteca proporciona un método encadenado más rápido y más corto .

Por ejemplo:

 lib . red . bold . bgWhite ( ' ERROR ' )           // ✅ faster, shorter, readable
lib . red ( lib . bold ( lib . bgWhite ( ' ERROR ' ) ) ) //  slower, longer, unreadable

Banco simple

La prueba simple usa solo estilo único. Los picocolors, el colorette y el kleur no admiten la sintaxis encadenada o la ruptura de estilo correcta (wenn usado `n` en una cadena), por lo que son los más rápidos en este caso de uso simple. Sin función, sin sobrecarga de rendimiento .

 ansis . red ( 'foo' )
chalk . red ( 'foo' )
picocolors . red ( 'foo' )
. . .

 +  [email protected]    109.212.939 ops/sec
   [email protected]    108.044.800 ops/sec
   [email protected]          87.800.739 ops/sec
- > [email protected]          60.606.043 ops/sec  -44.5%
-  [email protected]          55.702.479 ops/sec  -48.9%
   [email protected]       37.069.069 ops/sec
   [email protected]    14.364.378 ops/sec
   [email protected]          7.060.583 ops/sec
   [email protected]       2.753.751 ops/sec
   [email protected]       897.746 ops/sec

Usando 2 estilos

Usando solo 2 estilos, Picocolors ya es un poco más lento, porque usar la sintaxis encadenada es más rápido que las llamadas anidadas.

 ansis . red . bold ( 'foo' )
chalk . red . bold ( 'foo' )
picocolors . red ( picocolors . bold ( 'foo' ) ) // chained syntax is not supported
. . .

 +  [email protected]          60.468.181 ops/sec
-  [email protected]     58.777.183 ops/sec    -2.8%
-  [email protected]          47.789.020 ops/sec   -21.5%
   [email protected]     33.387.988 ops/sec
   [email protected]       13.420.047 ops/sec
   [email protected]           5.972.681 ops/sec
   [email protected]     4.086.412 ops/sec
   [email protected]          3.018.244 ops/sec
   [email protected]       1.817.039 ops/sec
   [email protected]       695.601 ops/sec

Usando 3 estilos

Usando 3 estilos, Picocolors es 2 veces más lento que ANSIS.

 ansis . red . bold . bgWhite ( 'foo' )
chalk . red . bold . bgWhite ( 'foo' )
picocolors . red ( picocolors . bold ( picocolors . bgWhite ( 'foo' ) ) ) // chained syntax is not supported
. . .

 +  [email protected]          59.463.640 ops/sec
-  [email protected]          42.166.783 ops/sec  -29.0%
-  [email protected]     32.434.017 ops/sec  -45.5% (~2x slower than Ansis)
   [email protected]     13.008.117 ops/sec
   [email protected]        5.608.244 ops/sec
   [email protected]           5.268.630 ops/sec
   [email protected]     2.145.517 ops/sec
   [email protected]          1.686.728 ops/sec
   [email protected]       1.453.611 ops/sec
   [email protected]       590.467 ops/sec

Usando 4 estilos

En casos raros, cuando se usa 4 estilos, los picocolors se vuelven 3.4x más lento que ANSIS.

 ansis . red . bold . underline . bgWhite ( 'foo' )
chalk . red . bold . underline . bgWhite ( 'foo' )
picocolors . red ( picocolors . bold ( picocolors . underline ( picocolors . bgWhite ( 'foo' ) ) ) ) // chained syntax is not supported
. . .

 +  [email protected]          59.104.535 ops/sec
-  [email protected]          36.147.547 ops/sec  -38.8%
-  [email protected]     17.581.709 ops/sec  -70.2% (~3x slower than Ansis)
   [email protected]      7.981.171 ops/sec
   [email protected]           4.825.665 ops/sec
   [email protected]        3.729.880 ops/sec
   [email protected]     1.514.053 ops/sec
   [email protected]          1.229.999 ops/sec
   [email protected]       1.210.931 ops/sec
   [email protected]       481.073 ops/sec

Estilos profundamente anidados

La prueba compleja con estilos individuales profundamente anidados.

 c . green (
  `green ${ c . cyan (
    `cyan ${ c . red (
      `red ${ c . yellow (
        `yellow ${ c . blue (
          `blue ${ c . magenta ( `magenta ${ c . underline ( `underline ${ c . italic ( `italic` ) } underline` ) } magenta` ) } blue` ,
        ) } yellow` ,
      ) } red` ,
    ) } cyan` ,
  ) } green` ,
)

 +  [email protected]      1.110.056 ops/sec
-  [email protected]      1.073.299 ops/sec
- > [email protected]             847.246 ops/sec  -23.7%
   [email protected]          847.110 ops/sec
-  [email protected]             573.942 ops/sec  -48.3%
   [email protected]             471.285 ops/sec
   [email protected]            439.588 ops/sec
   [email protected]       382.862 ops/sec
   [email protected]         213.351 ops/sec
   [email protected]        41.097 ops/sec

Banco de colores

El punto de referencia utilizado en colorette para estilos individuales.

 c . red ( ` ${ c . bold ( ` ${ c . cyan ( ` ${ c . yellow ( 'yellow' ) } cyan` ) } ` ) } red` )

 +  [email protected]      3.861.384 ops/sec
   [email protected]      3.815.039 ops/sec
- > [email protected]           2.918.269 ops/sec  -24.4%
   [email protected]        2.548.564 ops/sec
-  [email protected]           2.502.850 ops/sec  -35.2%
   [email protected]           2.229.023 ops/sec
   [email protected]     1.426.279 ops/sec
   [email protected]          1.123.139 ops/sec
   [email protected]         481.708 ops/sec
   [email protected]       114.570 ops/sec

Banco del complejo de picocolors

El punto de referencia picocolors , ligeramente modificado. Se agregó un poco más de complejidad aplicando dos estilos a la palabra coloreada en lugar de uno.

 let index = 1e8 ;
c . red ( '.' ) +
c . yellow ( '.' ) +
c . green ( '.' ) +
c . red . bold ( ' ERROR ' ) +
c . red ( 'Add plugin ' + c . cyan . underline ( 'name' ) + ' to use time limit with ' + c . cyan ( ++ index ) ) ;

 +  [email protected]      2.601.559 ops/sec
- > [email protected]           2.501.227 ops/sec   -3.8%
   [email protected]      2.326.491 ops/sec
-  [email protected]           2.129.106 ops/sec  -18.1%
   [email protected]           1.780.496 ops/sec
   [email protected]        1.685.703 ops/sec
   [email protected]       838.542 ops/sec
   [email protected]            533.362 ops/sec
   [email protected]         287.558 ops/sec
   [email protected]        97.463 ops/sec

Nota

En esta prueba, que está más cerca del uso práctico, cada biblioteca utiliza el método de estilo más rápido disponible.

Entonces, chalk , ansis , ansi-colors , cli-color , colors-cli y colors usan método encadenado, por ejemplo, c.red.bold(' ERROR ') . Mientras que picocolors , colorette y kolorist usan llamadas anidadas, por ejemplo, c.red(c.bold(' ERROR ')) , porque no admite la sintaxis encadenada.

↑ Top

Cómo cambiar a ANSIS

ANSIS es un reemplazo potente, pequeño y rápido que no requiere migración de código para muchas bibliotecas similares.
Simplemente reemplace su import ... from ... o require(...) a ansis .

Reemplazo de la tiza, no se requiere migración

 - import chalk from 'chalk';
+ import chalk from 'ansis';

ANSIS admite la sintaxis de tiza y es compatible* con estilos y nombres de color, por lo que no necesita modificar el código original:

 chalk . red . bold ( 'Error!' ) ;

// colorize "Error: file not found!"
chalk . red ( `Error: ${ chalk . cyan . bold ( 'file' ) } not found!` ) ;

// ANSI 256 colors
chalk . ansi256 ( 93 ) ( 'Violet color' ) ;
chalk . bgAnsi256 ( 194 ) ( 'Honeydew, more or less' ) ;

// truecolor
chalk . hex ( '#FFA500' ) . bold ( 'Bold orange color' ) ;
chalk . rgb ( 123 , 45 , 67 ) . underline ( 'Underlined reddish color' ) ;
chalk . bgHex ( '#E0115F' ) ( 'Ruby' ) ;
chalk . bgHex ( '#96C' ) ( 'Amethyst' ) ;

Advertencia

ANSIS no es compatible con el estilo overline , porque no es ampliamente compatible y nadie lo usa.
Verifique su código y elimine el estilo overline :

 - chalk.red.overline('text');
+ chalk.red('text');

Opcionalmente, puede reescribir el mismo código para que sea aún más corto y limpio:

 import { red , cyan , ansi256 , bgAnsi256 , fg , bg , hex , rgb , bgHex , bgRgb } from 'ansis' ;

red . bold ( 'Error!' ) ; // using parentheses
red . bold `Error!` ;   // using template string

// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` ;

// ANSI 256 colors
ansi256 ( 93 ) `Violet color` ;
bgAnsi256 ( 194 ) `Honeydew, more or less` ;
fg ( 93 ) `Violet color` ; // alias for ansi256
bg ( 194 ) `Honeydew, more or less` ;  // alias for bgAnsi256

// truecolor
hex ( '#FFA500' ) . bold `Bold orange color` ;
rgb ( 123 , 45 , 67 ) . underline `Underlined reddish color` ;
bgHex ( '#E0115F' ) `Ruby` ;
bgHex ( '#96C' ) `Amethyst` ;

↑ Top

Reemplazo de entrega de colorette, no se requiere migración

 - import { red, bold, underline } from 'colorette';
+ import { red, bold, underline } from 'ansis';

ANSIS es totalmente compatible con los estilos colorette y los nombres de color, por lo que no necesita modificar el código original:

 red . bold ( 'Error!' ) ;
bold ( `I'm ${ red ( `da ba ${ underline ( "dee" ) } da ba` ) } daa` ) ;

Opcionalmente, puede reescribir el mismo código para que sea aún más corto y limpio:

 red . bold `Error!` ;
bold `I'm ${ red `da ba ${ underline `dee` } da ba` } daa` ;

↑ Top

Reemplazo de cable para los picocoloros, no se requiere migración

 - import pico from 'picocolors';
+ import pico from 'ansis';

ANSIS es totalmente compatible con los estilos picocolors y los nombres de color, por lo que no necesita modificar el código original:

 pico . red ( pico . bold ( 'text' ) ) ;
pico . red ( pico . bold ( variable ) ) ;

// colorize "Error: file not found!"
pico . red ( 'Error: ' + pico . cyan ( pico . bold ( 'file' ) ) + ' not found!' ) ;

Opcionalmente, puede reescribir el mismo código para que sea aún más corto y limpio:

 import { red , cyan } from 'ansis' ;

red . bold `text` ;
red . bold ( variable ) ;

// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!`

↑ Top

Reemplazo de entrega para los colores ANSI, no se requiere migración

 - const c = require('ansi-colors');
+ const c = require('ansis');

ANSIS es totalmente compatible con los estilos ansi-color y los nombres de color, por lo que no necesita modificar el código original:

 c . red . bold ( 'Error!' ) ;

// colorize "Error: file not found!"
c . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ;

Opcionalmente, puede reescribir el mismo código para que sea aún más corto y limpio:

 import { red , cyan } from 'ansis' ;

red . bold ( 'Error!' ) ; // using parentheses
red . bold `Error!` ;   // using template string

// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` ;

↑ Top

Migración de Kleur

 - import { red, green, yellow, cyan } from 'kleur';
+ import { red, green, yellow, cyan } from 'ansis';

ANSIS es totalmente compatible con los estilos kleur y los nombres de color, pero Kleur v3.0 ya no usa sintaxis al estilo de tiza (Getter mágico):

 green ( ) . bold ( ) . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red ( ) . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ;

Si usa métodos encadenados, requiere una modificación de código simple. Solo reemplazar (). con . :

 green . bold . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ;

Opcionalmente, puede reescribir el mismo código para que sea aún más corto y limpio:

 yellow `foo ${ red . bold `red` } bar ${ cyan `cyan` } baz` ;

↑ Top

Migración del cli-color

 - const clc = require('cli-color');
+ const clc = require('ansis');

ANSIS es compatible* con estilos cli-color y nombres de color:

 clc . red . bold ( 'Error!' ) ;

// colorize "Error: file not found!"
clc . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ;

Advertencia

ANSIS no es compatible con el estilo blink , porque no es ampliamente compatible y nadie lo usa.
Verifique su código y elimine el estilo blink :

 - clc.red.blink('text');
+ clc.red('text');

Si usa las funciones de color ANSI 256 xterm o bgXterm , estas deben reemplazarse con ansi256 fn o bgAnsi256 bg :

 - clc.xterm(202).bgXterm(236)('Orange text on dark gray background');
+ clc.ansi256(202).bgAnsi256(236)('Orange text on dark gray background');

Opcionalmente, puede reescribir el mismo código para que sea aún más corto y limpio:

 import { red , cyan , fg , bg } from 'ansis' ;

red . bold `Error!` ;

// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` ;

fg ( 202 ) . bg ( 236 ) `Orange text on dark gray background` ;

↑ Top

Pruebas

npm run test ejecutará la unidad y las pruebas de integración.
npm run test:coverage ejecutará las pruebas con cobertura.

↑ Top

Licencia

ISC

Los colores compatibles dependen de la terminal real. ↩ ↩ ² ↩ ³
El terminal de Windows admite color verdadero desde Windows 10 Revision 14931 (2016-09-21). ↩ ↩ ²

Expandir

ansis

Estilos de ansi

Instalar y iniciar rápidamente por qué cambiar a ANSIS

Uso

⚖️ Bibliotecas similares

Reflejos

? Utilizado por

Solicitud / Solicitud / error

Por qué cambiar a ANSIS

? Tamaño desempaquetado

⚡ Rendimiento

? Mantenimiento

? ¿Cuál deberías usar?

Cómo cambiar a ANSIS

↑ Top

Instalar y arrancar rápido

↑ Top

Nombrado importación

Literales de plantilla

Sintaxis encadenada

↑ Top

Sintaxis anidada

↑ Top

Base Ansi 16 colores y estilos

Extender los colores base

↑ Top

ANSI 256 colores

Retroceder

Ejemplo de uso

Truecolor

↑ Top

Retroceder

↑ Top

Usar códigos ANSI

Códigos ANSI de despegar

↑ Top

Nuevas líneas

Atajos / temas

↑ Top

Variables de entorno CLI

Usando COLORTERM

Fuerza Use Truecolor

Fuerza usa 256 colores

Fuerza Use la base de 16 colores

↑ Top

Argumentos de CLI

↑ Top

Soporte de color

↑ Top

Compare las características de las bibliotecas más populares

↑ Top

Compare el tamaño de los paquetes más populares

↑ Top

Mostrar demostración de ANSI

Puntos de referencia

Ejecutar puntos de referencia

Probado en

Banco simple

Usando 2 estilos

Usando 3 estilos

Usando 4 estilos

Estilos profundamente anidados

Banco de colores

Banco del complejo de picocolors

↑ Top

Cómo cambiar a ANSIS

Reemplazo de la tiza, no se requiere migración

↑ Top

Reemplazo de entrega de colorette, no se requiere migración

↑ Top

Reemplazo de cable para los picocoloros, no se requiere migración

↑ Top

Reemplazo de entrega para los colores ANSI, no se requiere migración

↑ Top

Migración de Kleur

↑ Top

Migración del cli-color

↑ Top

Pruebas

↑ Top

Usando `COLORTERM`