ascii-art

You can combine different ASCII elements (fonts, images, tables, etc.) into a single composition using chainable functions:

• .lines(): Combine elements into lines.
• .overlay(): Overlay one element on another.
• .border(): Add a border around the composition.
• .strip(): Remove certain elements.
• .join(): Join elements together.

All chains in ascii-art support three asynchronous calling styles. For example, when using .font() to render text with a specific Figlet font:

• Callback: Pass a callback function (err, rendered) => { ... }.
• Promise: Use .then() and .catch().
• Await: Use await art.font(...).completed() inside a try/catch block.

// Callback
art.font("Some Text", 'doom', (err, rendered) => {
    if (err) return console.error(err);
    console.log(rendered);
});

// Promise
art.font("Some Text', 'doom')
   .then((rendered) => {
       console.log(rendered);
   })
   .catch((err) => {
       console.error(err);
   });

// Await
try {
    let rendered = await art.font("Some Text", 'doom').completed();
    console.log(rendered);
} catch (err) {
    console.error(err);
}

Depending on your environment, install ascii-art using one of the following methods:

• In Code (Node.js/Bundlers): npm install --save ascii-art
• CLI (Global): npm install -g ascii-art or the beta npm install -g ascii-art-cl
• Web (Web Components): npm install --save ascii-art-webcomponents

If you are currently using chalk, you can switch to ascii-art without changing your existing syntax. Simply replace your import:

// Instead of:
// var chalk = require('chalk');

// Use:
var chalk = require('ascii-art/kaolin');

This allows you to keep using the chalk API while benefiting from ascii-art's expanded capabilities.

Use art.style(text, style, reset) to add ANSI styles to a string.

Available Styles:

• italic
• bold
• underline
• |framed|
• |encircled|
• overline
• blink
• inverse

Available Colors: Colors default to 8-bit output. You can enable higher fidelity modes via options:

• is256: Use 256-color mode (ansi256).
• isTrueColor: Output direct RGB (32-bit) to the console.

art.style("Some Text", 'green', true) // returns String

Use art.font(text, fontName, reset) to render a string using a Figlet font. The library acts as a package manager for fonts, defaulting to a /Fonts directory.

UTF Fonts: You can use system UTF fonts by prefixing the font name with u:. Supported names include:

• default, script, script+bold, gothic, gothic+bold, serif+bold+italic, serif+bold, serif+italic, monospace, sansserif, sansserif+bold+italic, sansserif+bold, sansserif+italic, doublestrike.

art.font("Some Text", 'doom', true) // returns String

The library provides methods to render structured data:

• Tables: art.table(data, callback) renders data into an ANSI-aware table. Supports various styles and handles column sizing based on ANSI string width.
• Graphs: art.graph(data, callback) renders data as a graph (e.g., using braille characters).

// Table
art.table({}, cb);

// Graph
art.graph({}, cb);

Use art.image(options, callback) to convert an image into ASCII/Braille art.

Key Image Options:

• src: Path to the image.
• rows / cols: Dimensions.
• stipple: A color (e.g., "#000000") used for braille character overlays.
• posterize: (Boolean) Uses stipple on top of colored backgrounds to retain detail.
• lineart: (Boolean) Outputs lineart using block characters.
• stipple (as boolean): Outputs lineart using braille characters.
• blended: Uses posterize with both lineart and braille at relative thresholds.
• threshold: (0-255) Controls detail level.

art.image({
    src: "myImage.jpg",
    rows: 80,
    cols: 80,
    stipple: "#000000",
    posterize: true,
    threshold: 40
}, cb);

Use AsciiArt.use(interfaceName, implementation) to inject custom logic for external dependencies like network requests.

Supported interfaces:

• 'request': Provides a custom implementation for AsciiArt.Image.useRequest and AsciiArt.Artwork.useRequest. This is useful if you want to use a specific HTTP client (like axios or node-fetch) instead of the default.
• 'artwork': Replaces the AsciiArt.Artwork module entirely.

const AsciiArt = require('ascii-art');

// Example: Injecting a custom request handler
AsciiArt.use('request', myCustomRequestLibrary);