console: do not emit error events · nodejs/node@f18e08d

const util = require('util');

function Console(stdout, stderr) {

function Console(stdout, stderr, ignoreErrors = true) {

if (!(this instanceof Console)) {

return new Console(stdout, stderr);

return new Console(stdout, stderr, ignoreErrors);

}

if (!stdout || typeof stdout.write !== 'function') {

throw new TypeError('Console expects a writable stream instance');

Object.defineProperty(this, '_stdout', prop);

prop.value = stderr;

Object.defineProperty(this, '_stderr', prop);

prop.value = ignoreErrors;

Object.defineProperty(this, '_ignoreErrors', prop);

prop.value = new Map();

Object.defineProperty(this, '_times', prop);

prop.value = createWriteErrorHandler(stdout);

Object.defineProperty(this, '_stdoutErrorHandler', prop);

prop.value = createWriteErrorHandler(stderr);

Object.defineProperty(this, '_stderrErrorHandler', prop);

// bind the prototype functions to this Console instance

var keys = Object.keys(Console.prototype);

}

}

// Make a function that can serve as the callback passed to `stream.write()`.

function createWriteErrorHandler(stream) {

return (err) => {

// This conditional evaluates to true if and only if there was an error

// that was not already emitted (which happens when the _write callback

// is invoked asynchronously).

if (err && !stream._writableState.errorEmitted) {

// If there was an error, it will be emitted on `stream` as

// an `error` event. Adding a `once` listener will keep that error

// from becoming an uncaught exception, but since the handler is

// removed after the event, non-console.* writes won’t be affected.

stream.once('error', noop);

}

};

}

function write(ignoreErrors, stream, string, errorhandler) {

if (!ignoreErrors) return stream.write(string);

// There may be an error occurring synchronously (e.g. for files or TTYs

// on POSIX systems) or asynchronously (e.g. pipes on POSIX systems), so

// handle both situations.

try {

// Add and later remove a noop error handler to catch synchronous errors.

stream.once('error', noop);

stream.write(string, errorhandler);

} catch (e) {

// Sorry, there’s no proper way to pass along the error here.

} finally {

stream.removeListener('error', noop);

}

}

// As of v8 5.0.71.32, the combination of rest param, template string

// and .apply(null, args) benchmarks consistently faster than using

// the spread operator when calling util.format.

Console.prototype.log = function log(...args) {

this._stdout.write(`${util.format.apply(null, args)}\n`);

write(this._ignoreErrors,

this._stdout,

`${util.format.apply(null, args)}\n`,

this._stdoutErrorHandler);

};

Console.prototype.info = Console.prototype.log;

Console.prototype.warn = function warn(...args) {

this._stderr.write(`${util.format.apply(null, args)}\n`);

write(this._ignoreErrors,

this._stderr,

`${util.format.apply(null, args)}\n`,

this._stderrErrorHandler);

};

Console.prototype.dir = function dir(object, options) {

options = Object.assign({customInspect: false}, options);

this._stdout.write(`${util.inspect(object, options)}\n`);

write(this._ignoreErrors, this._stdout, `${util.inspect(object, options)}\n`);

};

module.exports = new Console(process.stdout, process.stderr);

module.exports.Console = Console;

function noop() {}