Typo is a scalable template engine designed for cli, which help to format your console output! Typo supports full 256-color ANSI background and foreground, underline, italic, etc.

`typo` is an extendable template engine designed for the future

kael

typo

function mix (receiver, supplier, override){

        if(override || !(key in receiver)){

            receiver[key] = supplier[key]

// - clean: {boolean} if true, typo will not output SGR charactors

    this.colors = 'colors' in options ? options.colors : true;

Typo.prototype.write = function (value) {

Typo.prototype.log = function (template, params, callback) {

    this.template(template, params, function(err, value) {

            return callback && callback(err);

        callback && callback(null, value);

Typo.prototype.template = function (template, params, callback) {

    if(arguments.length === 2 && typeof params === 'function'){

    var value = substitute(template, params, this._helpers, function (err, value) {

            callback(null, self._clean(value));

// Register a helper function or register several helpers

// @param {function(value[, callback])} parser

//  - callback: {function(err, value)} if there's `callback` arguemtn in parser, `parser` will be considered as an asynchronous method

Typo.prototype.register = function(pattern, parser) {

    Typo._register(this._helpers, pattern, parser);

Typo.prototype.plugin = function(plugin) {

Typo._register = function (host, pattern, parser){

            Typo._register(host, pattern, parser);

    }else if(typeof pattern === 'string' && typeof parser === 'function'){

Typo.prototype._clean = function (subject) {

    return this.clean ? subject && subject.replace(REGEX_CGR, '') : subject;

    return !this.colors ? subject && subject.replace(REGEX_CGR, '') : subject;

mix(Helpers.prototype, require('./helper/cgr'));

  "description": "Typo is a scalable template engine designed for cli, which help to format your console output! Typo supports full 256-color ANSI background and foreground, underline, italic, etc.",

    "test": "echo \"Error: no test specified\" && exit 1"

    "url": "git://github.com/kaelzhang/typo.git"

    "url": "https://github.com/kaelzhang/typo/issues"

> Make typography beautiful in command-line.

Typo is a scalable node.js template engine designed for and focused on command-line (cli), which helps to format and beautify your console output.

Typo supports not only basic [ANSI escope codes](http://en.wikipedia.org/wiki/ANSI_escape_code), such as basic background and foreground colors, underline, bold, etc, and **ALSO** full 8-bit colors (256 colors).

![screenshot](https://raw.github.com/kaelzhang/typo/master/screenshot.png)

Typo is a [`Readable stream`](http://nodejs.org/api/stream.html#stream_class_stream_readable), which means you can `.pipe()` and `.on('data', c)` with it.

typo.log("There's once in a {{blue blue}} moon~");

- [typo-rgb](https://github.com/kaelzhang/typo-rgb): support full 8-bit RGB colors !

- [typo-image](https://github.com/kaelzhang/typo-image): display pictures in CLI !

- [typo-ascii](https://github.com/kaelzhang/typo-ascii): ascii art text in CLI with all kinds of styles ! (on developing)

	( '{{<helper[:<data>][|helper[:<data>]]> <text>}}', <object> );

typo.log('{{1}}{{b}}{{c.a}}{{c.b}}', {'1': 1, b:2, c: {a: 3}}); 

// in which, `'c.b'` is not matched in `values` and not substituted.

typo.log('{{bold abc}}');         // print a bold 'abc'

typo.log('{{red abc}}');  		   // print a red 'abc'

typo.log('{{bold|blue|underline abc}}'); // print a blue bold 'abc' with a underline

    return value.split(',').reduce(function(prev, current){

        return (parseInt(current) || 0) + prev;

typo.log('{{sum 1,2,3}}');         // print 6

typo.log('{{~image ./logo.png}}');  // will print the png image to the CLI !

Which will not show up before `typo@1.0.0`.

if you like `typo`, there will be a billion thanks if you fork `typo` and make pull requests.

If true, typo will clean all styles and output pure text, which is really helpfull if you use typo in CI.

If true, typo will clean all styles (colors, bold, etc) and output the pure text, which is really helpfull if you use typo in CI.

The writeable stream to write into. If set, typo will `.pipe()` output to that stream.

However, you could also use `.pipe()` method to do this.

The End-of-Sentence. By default, it's a carriage return.

These methods below is the methods of the typo instance.

### typo.log(pattern [,values [,callback]])

Print a formated output to the command-line. Has no return value.

If no `values` passed or not matched, the relevant pattern will not be substituted.

Typo also support asynchronous help functions. See "register asynchronous helpers" section.

### typo.template(pattern [,values [,callback]])

The parsed or substituted ouput, if all helpers are synchronous.

Register helpers for the current instance

Will be treated as a sync helper, if has **only one** [term parameter](http://en.wikipedia.org/wiki/Parameter_(computer_programming) (also called formal parameter);

Besides, the `data` (in "syntax" section) could be fetched using `this.data` inside `helper`.

If helper has more than one term parameters, it will be treated as an async helper.

And the second parameter will be the callback which should be implemented inside the helper function.

Typo.register(helpers); // the same parameters as `typo.register`

Typo.plugin(plugin);	 // the same parameters as `typo.plugin`

    clean: ~ process.argv.indexOf('--clean'),

    colors: ! ~ process.argv.indexOf('--clean'),

var a = 'abc{{blue|bold blu e}}{{blue blue}} eee{{bold a}} {{0}}abc{{red red}}';

typo.log(a, {a: 'bold'}, function(err, value) {

typo.log('{{italic a}}{{b}}{{c.a}}{{c.b}}', {a: 1, b:2, c: {a: 3}}, function(err, value) {

typo.log('{{underline a}}', {a: 1}, function(err, value) {

    return (Array.isArray(value) ? value : [value])

            return (parseInt(current) || 0) + prev;

typo.log('{{sum 1,2,3}}');      // print 6

// 	'{{bg.rgb:#f26d7d|rgb:#000 peach bg and black font}}' +

// 	'{{bg.rgb:#f26d7d peach bg and white font}}'

		@@ -35,8 +35,9 @@ 'use strict';

		this.clean = options.clean;
		this._helpers = new Typo.Helpers();
		this.colors = 'colors' in options ? options.colors : true;
		this.EOS = options.EOS \|\| '\n';

		var output = options.output;
		output && this.pipe(output);

		output && this.pipe(output);
		this._helpers = new Typo.Helpers();
		};
		@@ -60,3 +61,3 @@

		self.write(value);
		self.write(value + self.EOS);

		@@ -136,3 +137,3 @@ callback && callback(null, value);
		Typo.prototype._clean = function (subject) {
		return this.clean ? subject && subject.replace(REGEX_CGR, '') : subject;
		return !this.colors ? subject && subject.replace(REGEX_CGR, '') : subject;
		};
		@@ -139,0 +140,0 @@

		{
		"name": "typo",
		"version": "0.1.12",
		"version": "0.1.13",
		"description": "Typo is a scalable template engine designed for cli, which help to format your console output! Typo supports full 256-color ANSI background and foreground, underline, italic, etc.",
		@@ -5,0 +5,0 @@ "main": "index.js",

		@@ -162,7 +162,7 @@ # Typo

		##### options.clean `Boolean`
		##### options.colors `Boolean`

		Optional, default to `false`
		Optional, default to `true`

		If true, typo will clean all styles and output pure text, which is really helpfull if you use typo in CI.
		If true, typo will clean all styles (colors, bold, etc) and output the pure text, which is really helpfull if you use typo in CI.

		@@ -177,3 +177,9 @@ ##### options.output `Stream.Writeable`

		##### options.EOS `String`

		Optional, default to `'\n'`

		The End-of-Sentence. By default, it's a carriage return.


		## Instance Methods
		@@ -180,0 +186,0 @@

		'use strict';

		var typo = require('typo')({
		clean: ~ process.argv.indexOf('--clean'),
		colors: ! ~ process.argv.indexOf('--clean'),
		output: process.stdout
		@@ -6,0 +6,0 @@ });

Improved metrics