Skip to main content
Go to Latest
File
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678
// Copyright 2018-2022 Deno authors. All rights reserved. MIT license.// Copyright Joyent and Node contributors. All rights reserved. MIT license.
// Mock trace for nowconst trace = () => {};import { ERR_CONSOLE_WRITABLE_STREAM, ERR_INCOMPATIBLE_OPTION_PAIR, ERR_INVALID_ARG_VALUE, isStackOverflowError,} from "../errors.ts";import { validateArray, validateInteger, validateObject,} from "../validators.mjs";const previewEntries = (iter, isKeyValue) => { if (isKeyValue) { const arr = [...iter]; if (Array.isArray(arr[0]) && arr[0].length === 2) { return [[].concat(...arr), true]; } return [arr, false]; } else { return [...iter]; }};import { Buffer } from "../../buffer.ts";const { isBuffer } = Buffer;import { formatWithOptions, inspect } from "../util/inspect.mjs";import { isMap, isMapIterator, isSet, isSetIterator, isTypedArray,} from "../util/types.ts";import { CHAR_LOWERCASE_B as kTraceBegin, CHAR_LOWERCASE_E as kTraceEnd, CHAR_LOWERCASE_N as kTraceInstant, CHAR_UPPERCASE_C as kTraceCount,} from "../constants.ts";import { clearScreenDown, cursorTo } from "../readline/callbacks.mjs";import cliTable from "../cli_table.ts";const kCounts = Symbol("counts");
const kTraceConsoleCategory = "node,node.console";
const kSecond = 1000;const kMinute = 60 * kSecond;const kHour = 60 * kMinute;const kMaxGroupIndentation = 1000;
// Track amount of indentation required via `console.group()`.const kGroupIndent = Symbol("kGroupIndent");const kGroupIndentationWidth = Symbol("kGroupIndentWidth");const kFormatForStderr = Symbol("kFormatForStderr");const kFormatForStdout = Symbol("kFormatForStdout");const kGetInspectOptions = Symbol("kGetInspectOptions");const kColorMode = Symbol("kColorMode");const kIsConsole = Symbol("kIsConsole");const kWriteToConsole = Symbol("kWriteToConsole");const kBindProperties = Symbol("kBindProperties");const kBindStreamsEager = Symbol("kBindStreamsEager");const kBindStreamsLazy = Symbol("kBindStreamsLazy");const kUseStdout = Symbol("kUseStdout");const kUseStderr = Symbol("kUseStderr");
const optionsMap = new WeakMap();
function Console(options /* or: stdout, stderr, ignoreErrors = true */) { // We have to test new.target here to see if this function is called // with new, because we need to define a custom instanceof to accommodate // the global console. if (!new.target) { return Reflect.construct(Console, arguments); }
if (!options || typeof options.write === "function") { options = { stdout: options, stderr: arguments[1], ignoreErrors: arguments[2], }; }
const { stdout, stderr = stdout, ignoreErrors = true, colorMode = "auto", inspectOptions, groupIndentation, } = options;
if (!stdout || typeof stdout.write !== "function") { throw new ERR_CONSOLE_WRITABLE_STREAM("stdout"); } if (!stderr || typeof stderr.write !== "function") { throw new ERR_CONSOLE_WRITABLE_STREAM("stderr"); }
if (typeof colorMode !== "boolean" && colorMode !== "auto") { throw new ERR_INVALID_ARG_VALUE("colorMode", colorMode); }
if (groupIndentation !== undefined) { validateInteger( groupIndentation, "groupIndentation", 0, kMaxGroupIndentation, ); }
if (inspectOptions !== undefined) { validateObject(inspectOptions, "options.inspectOptions");
if ( inspectOptions.colors !== undefined && options.colorMode !== undefined ) { throw new ERR_INCOMPATIBLE_OPTION_PAIR( "options.inspectOptions.color", "colorMode", ); } optionsMap.set(this, inspectOptions); }
// Bind the prototype functions to this Console instance Object.keys(Console.prototype).forEach((key) => { // We have to bind the methods grabbed from the instance instead of from // the prototype so that users extending the Console can override them // from the prototype chain of the subclass. this[key] = this[key].bind(this); Object.defineProperty(this[key], "name", { value: key, }); });
this[kBindStreamsEager](stdout, stderr); this[kBindProperties](ignoreErrors, colorMode, groupIndentation);}
const consolePropAttributes = { writable: true, enumerable: false, configurable: true,};
// Fixup global.console instanceof global.console.ConsoleObject.defineProperty(Console, Symbol.hasInstance, { value(instance) { return instance === console || instance[kIsConsole]; },});
const kColorInspectOptions = { colors: true };const kNoColorInspectOptions = {};
Object.defineProperties(Console.prototype, { [kBindStreamsEager]: { ...consolePropAttributes, // Eager version for the Console constructor value: function (stdout, stderr) { Object.defineProperties(this, { "_stdout": { ...consolePropAttributes, value: stdout }, "_stderr": { ...consolePropAttributes, value: stderr }, }); }, }, [kBindStreamsLazy]: { ...consolePropAttributes, // Lazily load the stdout and stderr from an object so we don't // create the stdio streams when they are not even accessed value: function (object) { let stdout; let stderr; Object.defineProperties(this, { "_stdout": { enumerable: false, configurable: true, get() { if (!stdout) stdout = object.stdout; return stdout; }, set(value) { stdout = value; }, }, "_stderr": { enumerable: false, configurable: true, get() { if (!stderr) stderr = object.stderr; return stderr; }, set(value) { stderr = value; }, }, }); }, }, [kBindProperties]: { ...consolePropAttributes, value: function (ignoreErrors, colorMode, groupIndentation = 2) { Object.defineProperties(this, { "_stdoutErrorHandler": { ...consolePropAttributes, value: createWriteErrorHandler(this, kUseStdout), }, "_stderrErrorHandler": { ...consolePropAttributes, value: createWriteErrorHandler(this, kUseStderr), }, "_ignoreErrors": { ...consolePropAttributes, value: Boolean(ignoreErrors), }, "_times": { ...consolePropAttributes, value: new Map() }, // Corresponds to https://console.spec.whatwg.org/#count-map [kCounts]: { ...consolePropAttributes, value: new Map() }, [kColorMode]: { ...consolePropAttributes, value: colorMode }, [kIsConsole]: { ...consolePropAttributes, value: true }, [kGroupIndent]: { ...consolePropAttributes, value: "" }, [kGroupIndentationWidth]: { ...consolePropAttributes, value: groupIndentation, }, [Symbol.toStringTag]: { writable: false, enumerable: false, configurable: true, value: "console", }, }); }, }, [kWriteToConsole]: { ...consolePropAttributes, value: function (streamSymbol, string) { const ignoreErrors = this._ignoreErrors; const groupIndent = this[kGroupIndent];
const useStdout = streamSymbol === kUseStdout; const stream = useStdout ? this._stdout : this._stderr; const errorHandler = useStdout ? this._stdoutErrorHandler : this._stderrErrorHandler;
if (groupIndent.length !== 0) { if (string.includes("\n")) { string = string.replace(/\n/g, `\n${groupIndent}`); } string = groupIndent + string; } string += "\n";
if (ignoreErrors === false) 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. if (stream.listenerCount("error") === 0) { stream.once("error", noop); }
stream.write(string, errorHandler); } catch (e) { // Console is a debugging utility, so it swallowing errors is not // desirable even in edge cases such as low stack space. if (isStackOverflowError(e)) { throw e; } // Sorry, there's no proper way to pass along the error here. } finally { stream.removeListener("error", noop); } }, }, [kGetInspectOptions]: { ...consolePropAttributes, value: function (stream) { let color = this[kColorMode]; if (color === "auto") { color = stream.isTTY && ( typeof stream.getColorDepth === "function" ? stream.getColorDepth() > 2 : true ); }
const options = optionsMap.get(this); if (options) { if (options.colors === undefined) { options.colors = color; } return options; }
return color ? kColorInspectOptions : kNoColorInspectOptions; }, }, [kFormatForStdout]: { ...consolePropAttributes, value: function (args) { const opts = this[kGetInspectOptions](this._stdout); args.unshift(opts); return Reflect.apply(formatWithOptions, null, args); }, }, [kFormatForStderr]: { ...consolePropAttributes, value: function (args) { const opts = this[kGetInspectOptions](this._stderr); args.unshift(opts); return Reflect.apply(formatWithOptions, null, args); }, },});
// Make a function that can serve as the callback passed to `stream.write()`.function createWriteErrorHandler(instance, streamSymbol) { 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). const stream = streamSymbol === kUseStdout ? instance._stdout : instance._stderr; if (err !== null && !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. // we are only adding noop if there is no one else listening for 'error' if (stream.listenerCount("error") === 0) { stream.once("error", noop); } } };}
const consoleMethods = { log(...args) { this[kWriteToConsole](kUseStdout, this[kFormatForStdout](args)); },
warn(...args) { this[kWriteToConsole](kUseStderr, this[kFormatForStderr](args)); },
dir(object, options) { this[kWriteToConsole]( kUseStdout, inspect(object, { customInspect: false, ...this[kGetInspectOptions](this._stdout), ...options, }), ); },
time(label = "default") { // Coerces everything other than Symbol to a string label = `${label}`; if (this._times.has(label)) { emitWarning(`Label '${label}' already exists for console.time()`); return; } trace(kTraceBegin, kTraceConsoleCategory, `time::${label}`, 0); this._times.set(label, process.hrtime()); },
timeEnd(label = "default") { // Coerces everything other than Symbol to a string label = `${label}`; const found = timeLogImpl(this, "timeEnd", label); trace(kTraceEnd, kTraceConsoleCategory, `time::${label}`, 0); if (found) { this._times.delete(label); } },
timeLog(label = "default", ...data) { // Coerces everything other than Symbol to a string label = `${label}`; timeLogImpl(this, "timeLog", label, data); trace(kTraceInstant, kTraceConsoleCategory, `time::${label}`, 0); },
trace: function trace(...args) { const err = { name: "Trace", message: this[kFormatForStderr](args), }; Error.captureStackTrace(err, trace); this.error(err.stack); },
assert(expression, ...args) { if (!expression) { args[0] = `Assertion failed${args.length === 0 ? "" : `: ${args[0]}`}`; // The arguments will be formatted in warn() again Reflect.apply(this.warn, this, args); } },
// Defined by: https://console.spec.whatwg.org/#clear clear() { // It only makes sense to clear if _stdout is a TTY. // Otherwise, do nothing. if (this._stdout.isTTY && process.env.TERM !== "dumb") { cursorTo(this._stdout, 0, 0); clearScreenDown(this._stdout); } },
// Defined by: https://console.spec.whatwg.org/#count count(label = "default") { // Ensures that label is a string, and only things that can be // coerced to strings. e.g. Symbol is not allowed label = `${label}`; const counts = this[kCounts]; let count = counts.get(label); if (count === undefined) { count = 1; } else { count++; } counts.set(label, count); trace(kTraceCount, kTraceConsoleCategory, `count::${label}`, 0, count); this.log(`${label}: ${count}`); },
// Defined by: https://console.spec.whatwg.org/#countreset countReset(label = "default") { const counts = this[kCounts]; if (!counts.has(label)) { emitWarning(`Count for '${label}' does not exist`); return; } trace(kTraceCount, kTraceConsoleCategory, `count::${label}`, 0, 0); counts.delete(`${label}`); },
group(...data) { if (data.length > 0) { Reflect.apply(this.log, this, data); } this[kGroupIndent] += " ".repeat(this[kGroupIndentationWidth]); },
groupEnd() { this[kGroupIndent] = this[kGroupIndent].slice( 0, this[kGroupIndent].length - this[kGroupIndentationWidth], ); },
// https://console.spec.whatwg.org/#table table(tabularData, properties) { console.log("tabularData", tabularData); if (properties !== undefined) { validateArray(properties, "properties"); }
if (tabularData === null || typeof tabularData !== "object") { return this.log(tabularData); }
const final = (k, v) => this.log(cliTable(k, v));
const _inspect = (v) => { const depth = v !== null && typeof v === "object" && !isArray(v) && Object.keys(v).length > 2 ? -1 : 0; const opt = { depth, maxArrayLength: 3, breakLength: Infinity, ...this[kGetInspectOptions](this._stdout), }; return inspect(v, opt); }; const getIndexArray = (length) => Array.from( { length }, (_, i) => _inspect(i), );
const mapIter = isMapIterator(tabularData); let isKeyValue = false; let i = 0; if (mapIter) { const res = previewEntries(tabularData, true); tabularData = res[0]; isKeyValue = res[1]; }
if (isKeyValue || isMap(tabularData)) { const keys = []; const values = []; let length = 0; if (mapIter) { for (; i < tabularData.length / 2; ++i) { keys.push(_inspect(tabularData[i * 2])); values.push(_inspect(tabularData[i * 2 + 1])); length++; } } else { for (const { 0: k, 1: v } of tabularData) { keys.push(_inspect(k)); values.push(_inspect(v)); length++; } } return final([ iterKey, keyKey, valuesKey, ], [ getIndexArray(length), keys, values, ]); }
const setIter = isSetIterator(tabularData); if (setIter) { tabularData = previewEntries(tabularData); }
const setlike = setIter || mapIter || isSet(tabularData); if (setlike) { const values = []; let length = 0; console.log("tabularData", tabularData); for (const v of tabularData) { values.push(_inspect(v)); length++; } return final([iterKey, valuesKey], [getIndexArray(length), values]); }
const map = Object.create(null); let hasPrimitives = false; const valuesKeyArray = []; const indexKeyArray = Object.keys(tabularData);
for (; i < indexKeyArray.length; i++) { const item = tabularData[indexKeyArray[i]]; const primitive = item === null || (typeof item !== "function" && typeof item !== "object"); if (properties === undefined && primitive) { hasPrimitives = true; valuesKeyArray[i] = _inspect(item); } else { const keys = properties || Object.keys(item); for (const key of keys) { if (map[key] === undefined) { map[key] = []; } if ( (primitive && properties) || !Object.hasOwn(item, key) ) { map[key][i] = ""; } else { map[key][i] = _inspect(item[key]); } } } }
const keys = Object.keys(map); const values = Object.values(map); if (hasPrimitives) { keys.push(valuesKey); values.push(valuesKeyArray); } keys.unshift(indexKey); values.unshift(indexKeyArray);
return final(keys, values); },};
// Returns true if label was foundfunction timeLogImpl(self, name, label, data) { const time = self._times.get(label); if (time === undefined) { emitWarning(`No such label '${label}' for console.${name}()`); return false; } const duration = process.hrtime(time); const ms = duration[0] * 1000 + duration[1] / 1e6;
const formatted = formatTime(ms);
if (data === undefined) { self.log("%s: %s", label, formatted); } else { self.log("%s: %s", label, formatted, ...data); } return true;}
function pad(value) { return `${value}`.padStart(2, "0");}
function formatTime(ms) { let hours = 0; let minutes = 0; let seconds = 0;
if (ms >= kSecond) { if (ms >= kMinute) { if (ms >= kHour) { hours = Math.floor(ms / kHour); ms = ms % kHour; } minutes = Math.floor(ms / kMinute); ms = ms % kMinute; } seconds = ms / kSecond; }
if (hours !== 0 || minutes !== 0) { ({ 0: seconds, 1: ms } = seconds.toFixed(3).split(".")); const res = hours !== 0 ? `${hours}:${pad(minutes)}` : minutes; return `${res}:${pad(seconds)}.${ms} (${hours !== 0 ? "h:m" : ""}m:ss.mmm)`; }
if (seconds !== 0) { return `${seconds.toFixed(3)}s`; }
return `${Number(ms.toFixed(3))}ms`;}
const keyKey = "Key";const valuesKey = "Values";const indexKey = "(index)";const iterKey = "(iteration index)";
const isArray = (v) => Array.isArray(v) || isTypedArray(v) || isBuffer(v);
function noop() {}
for (const method of Reflect.ownKeys(consoleMethods)) { Console.prototype[method] = consoleMethods[method];}
Console.prototype.debug = Console.prototype.log;Console.prototype.info = Console.prototype.log;Console.prototype.dirxml = Console.prototype.log;Console.prototype.error = Console.prototype.warn;Console.prototype.groupCollapsed = Console.prototype.group;
export { Console, formatTime, kBindProperties, kBindStreamsLazy };export default { Console, kBindStreamsLazy, kBindProperties, formatTime,};