Pollito

A simple colorized logger

Pollito is a very simple logger with some color customizations.

How to use:

Create a new instance with new:

const pollito = new Pollito();

We can create a new instance of Pollito logger with new. We get an object of type Pollito.

Create a new instance with the creator method:

const pollito = Pollito.createInstance();

We get a new isntance of Pollito logger with this method.

It does not matter the creation method to get a instance. The created instance itself will be added to an internal static object in Pollito, accessible with the name of the intance. If we do not provide a name for the instance, automatically it will be named as pollito(length + 1).

Options for the constructor

We can provide some options at construction time of a new instance of Pollito:

• options: <Object> Optional argument. It can has the props: Default: {}
  • instanceName: <string> The name for the instance. Default: pollito + Pollito.instances.length + 1
  • stringColor: <string> The color used to print strings. Default: normal yellow
  • numberColor: <string> The color used to print numbers. Default: normal magenta
  • arrayStartColor: <string> The color used for the first level of an array. Default: normal red,
  • watch: <Object> Options to watch and emphasise a string.
    • string: <string> The string to watch
    • watchColor: <string> The color used to emphasise the string
    • watchBackground: <string> The color used as background to emphasise the string

All these arguments are optionals, unless watch.string if watch object is present.

Recover the Pollito logger from instances array

We can keep all our different Pollito instances in our Pollito.instances object. So we can access them whenever we need them.

We can supose we have created an instance named as pollito_red:

Pollito.createInstance({
    instanceName: 'pollito_red',
    stringColor: 'bright red'
});

After we call the Pollito.createInstance or new Pollito, a new instance is returned by the method or constructor. At the same time, the instance is saved to Pollito.instances object.

We can recover the instance created with Pollito.getInsance:

const pollitoRed = Pollito.getInstance('pollito_red');

How to log something

We have 3 different and simple methods to log data:

pollitoInstance.log(...data)

• ...data ...<string[]> | ...<any[]> | ...<object[]>

Log to the console all the data passed as argument, colon separated. It will be printed separated by a colon and a \n character.

pollito.log('hello', [1, 2, 3, 'something', undefined, null], { 'hello': 'world', or: { some: 'thing' } })

Output:

pollitoInstance.dateLog(data[, options])

• data <string> | <any[]> | <Object>
• options <Object>
  • dateFormat <string> The format to print the date object. Default: localeString

Log something to the console, with the addition of the printing date-time

pollito.dateLog({hello: 'world'});

Output:

possible values for dateFormat:

---

Value	Description
localeString	Calls the method toLocaleString
string	Calls the method toString
miliseconds	Parse the Date object to milliseconds

pollitoInstance.stringify(value)

• value <any>

It calls internally to JSON.stringify, printing the result with no formats or colors.

pollito.stringify({ hello: 'world' });

Output:

{"hello":"world"}

Watch a string

We can set a string to watch, so if it beign printed, it will have a background and a text color differente than the other text.

Ejample:

const pollito = new Pollito({
    watch: {
        string: 'he',
        watchBackground: 'bright magenta',
        watchColor: 'bright cyan'
    }
});

pollito.log({ hello: 'world', reheat: 'the chicken', something: '`helse`' });

Output:

The watch options are set at instance creation time. However, we can modify these options with the methods:

pollitoInstance.setWatchString(string)

• string <string> The new string to watch

pollito.setWatchString('hello');

pollitoInstance.setWatchBg(bg)

• bg <string> The new background color the watching string will have when printed

pollito.setWatchBg('bright magenta');

pollitoIsntance.setWatchColor(color)

• color <string> The new text color the watched string is going to use when printed

pollito.setWatchColor('normal red');

Possible colors for text

Normal colors	Bright colors
normal blue	bright blue
normal red	bright red
normal green	bright green
normal magenta	bright magenta
normal cyan	bright cyan
normal yellow	bright yellow

Possible colors for background

Normal colors	Bright colors
normal blue	bright blue
normal red	bright red
normal green	bright green
normal magenta	bright magenta
normal cyan	bright cyan
normal yellow	bright yellow
normal black	bright black
normal white	bright white

License

Lisence under MIT.