Added support for interactive mode. Fixes #12

[RyanBruno]

This new update function simply removes the previous line and then optionaly calls another logger to replace it. An example use case would be:

signale.pending();
// Do something
signale.update(signale.complete, 'done');

The update function clears the previous line and calls the complete function with 'done' as its parameter.
Fixes #12

[klaudiosinani]

Nice work! A few changes to be made and it is good to go : )

[jordrake]

Would you mind updating this to handle the streams per type and multiple stream as in here?
#27

You'll need to expose the type's custom streams to do this.

[RyanBruno]

It took me a few trys but I think I got it to work for both multiple and custom streams. @jordrake

[RyanBruno]

@klauscfhq What other changes need to be made?

[klaudiosinani]

@RyanBruno A couple more tweaks in order to simplify the usage and creation of the interactive loggers, and it is good to be merged! : )

[RyanBruno]

@klauscfhq Awesome! What tweaks specifically? The link in your previous comment was just https://github.com/klauscfhq/signale/pull/21/files

[jordrake]

this._formatStream(type.stream || this._stream);

As type.stream can also be an array or a single stream.

[klaudiosinani]

@RyanBruno My bad, here are the change notes:

signale.js@Line 3

The readline import can be removed, since we can call all the needed methods directly on the in-use writable stream:

const readline = require('readline'); // Can be omitted since it is a redundant requirement

signale.js@Line 262

We can ovoid calling the update() method manually, since that would be a very unintuitive way to use the interactive mode, and have it all done automatically by creating a new method, directly integrated inside of _log(), like so:

_write(stream, message) { // `_write()` can replace `update()` and simply use a boolean `this._interactive` variable to determine if the logger is in the interactive mode
  if (this._interactive) {
    // Note that `readline` is not needed, since all these methods can be directly called on the writable stream
    stream.moveCursor(0, -1); 
    stream.clearLine();
    stream.cursorTo(0);
  }
  stream.write(message + '\n');
}

_log(message, streams = this._stream) {
  this._formatStream(streams).forEach(stream => {
    // Use `_write()` inside of `_log()` to automatically achieve interactive messages.
    this._write(stream, message);
  });
}

signale.js@Line 20

Also, we should add the new boolean constructor attribute this._interactive, that will act as a user-option (e.g. const interactiveLogger = new Signale({interactive: true});) for creating interactive Signale instances. It can be included on line 20, just above the other attributes:

constructor(options = {}) {
   this._interactive = options.interactive || false; // We add `this._interactive` with a default state of `false`
   this._config = Object.assign(this.packageConfiguration, options.config);
   this._customTypes = Object.assign({}, options.types);
   this._scopeName = options.scope || '';
   this._timers = options.timers || new Map();
   this._types = Object.assign({}, types, this._customTypes);
   // ...
}

[RyanBruno]

Ah. I understand what you are going for now. I swapped the update function for the interactive mode. Thanks for the help! Let me know if any more changes are needed.

[klaudiosinani]

Looks awesome! Thank you a lot for taking the time to contribute! : )

[klaudiosinani]

It is possible to directly call these function on the in-use writable stream:

this._stream.moveCursor(0, -1);
this._stream.clearLine();
this._stream.cursorTo(0);

[klaudiosinani]

It is possible to avoid the process of having to manually call the update() function, in order for the last log message to be overridden, and have it done automatically by integrating it inside the _log() method.

_log(message) {
+  if (this._interactive) {
+    this._stream.moveCursor(0, -1);
+    this._stream.clearLine();
+    this._stream.cursorTo(0);
+  }
  this._stream.write(message + '\n');
}

The only extra addition should be a new boolean constructor attribute, e.g. this._interactive, that will act as an user option for creating an interactive Signale instance:

e.g. const interactiveLogger = new Signale({interactive: true});

The default state should be false

constructor(options = {}) {
+  this._interactive = options.interactive || false;
   this._config = Object.assign(this.packageConfiguration, options.config);
   this._customTypes = Object.assign({}, options.types);
   this._scopeName = options.scope || '';
   this._timers = options.timers || new Map();
   this._types = Object.assign({}, types, this._customTypes);
   this._stream = options.stream || process.stdout;
   // ...
}

[klaudiosinani]

This import can be removed since we are calling the needed methods directly on the in-use writable stream

[klaudiosinani]

This still has to be removed since it is redundant

[klaudiosinani]

For the same previously described reasons, there is no need to manually call the update() method, since that would be a very unintuitive way to use the interactive mode.

It can all be done automatically, by replacing update() with a new method, can be named _write() or _update() , which can be directly integrated inside of the already existing _log() , e.g:

_write(stream, message) {
  if (this._interactive) {
    // Note that `readline` is not needed, since all these methods can be directly called on the writable stream
    stream.moveCursor(0, -1); 
    stream.clearLine();
    stream.cursorTo(0);
  }
  stream.write(message + '\n');
}

_log(message, streams = this._stream) {
  this._formatStream(streams).forEach(stream => {
    // Use `_write()` inside of `_log()` to automatically achieve interactive messages.
    this._write(stream, message);
  });
}

Also, a new boolean constructor attribute is needed, e.g. this._interactive, so it can act as a user-option for creating interactive Signale instances:

e.g. const interactiveLogger = new Signale({interactive: true});

It can be added to the constructor like so:

constructor(options = {}) {
+  this._interactive = options.interactive || false;
   this._config = Object.assign(this.packageConfiguration, options.config);
   this._customTypes = Object.assign({}, options.types);
   this._scopeName = options.scope || '';
   this._timers = options.timers || new Map();
   this._types = Object.assign({}, types, this._customTypes);
   // ...
}