diff options
Diffstat (limited to 'node_modules/concurrently/dist/src/logger.js')
| -rw-r--r-- | node_modules/concurrently/dist/src/logger.js | 202 |
1 files changed, 202 insertions, 0 deletions
diff --git a/node_modules/concurrently/dist/src/logger.js b/node_modules/concurrently/dist/src/logger.js new file mode 100644 index 0000000..5fb368c --- /dev/null +++ b/node_modules/concurrently/dist/src/logger.js @@ -0,0 +1,202 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Logger = void 0; +const chalk_1 = __importDefault(require("chalk")); +const format_1 = __importDefault(require("date-fns/format")); +const lodash_1 = __importDefault(require("lodash")); +const Rx = __importStar(require("rxjs")); +const defaults = __importStar(require("./defaults")); +class Logger { + constructor({ hide, prefixFormat, prefixLength, raw = false, timestampFormat, }) { + /** + * Observable that emits when there's been output logged. + * If `command` is is `undefined`, then the log is for a global event. + */ + this.output = new Rx.Subject(); + // To avoid empty strings from hiding the output of commands that don't have a name, + // keep in the list of commands to hide only strings with some length. + // This might happen through the CLI when no `--hide` argument is specified, for example. + this.hide = lodash_1.default.castArray(hide) + .filter((name) => name || name === 0) + .map(String); + this.raw = raw; + this.prefixFormat = prefixFormat; + this.prefixLength = prefixLength || defaults.prefixLength; + this.timestampFormat = timestampFormat || defaults.timestampFormat; + } + shortenText(text) { + if (!text || text.length <= this.prefixLength) { + return text; + } + const ellipsis = '..'; + const prefixLength = this.prefixLength - ellipsis.length; + const endLength = Math.floor(prefixLength / 2); + const beginningLength = prefixLength - endLength; + const beginnning = text.slice(0, beginningLength); + const end = text.slice(text.length - endLength, text.length); + return beginnning + ellipsis + end; + } + getPrefixesFor(command) { + return { + pid: String(command.pid), + index: String(command.index), + name: command.name, + command: this.shortenText(command.command), + time: (0, format_1.default)(Date.now(), this.timestampFormat), + }; + } + getPrefix(command) { + const prefix = this.prefixFormat || (command.name ? 'name' : 'index'); + if (prefix === 'none') { + return ''; + } + const prefixes = this.getPrefixesFor(command); + if (Object.keys(prefixes).includes(prefix)) { + return `[${prefixes[prefix]}]`; + } + return lodash_1.default.reduce(prefixes, (prev, val, key) => { + const keyRegex = new RegExp(lodash_1.default.escapeRegExp(`{${key}}`), 'g'); + return prev.replace(keyRegex, String(val)); + }, prefix); + } + colorText(command, text) { + let color; + if (command.prefixColor && command.prefixColor.startsWith('#')) { + color = chalk_1.default.hex(command.prefixColor); + } + else { + const defaultColor = lodash_1.default.get(chalk_1.default, defaults.prefixColors, chalk_1.default.reset); + color = lodash_1.default.get(chalk_1.default, command.prefixColor ?? '', defaultColor); + } + return color(text); + } + /** + * Logs an event for a command (e.g. start, stop). + * + * If raw mode is on, then nothing is logged. + */ + logCommandEvent(text, command) { + if (this.raw) { + return; + } + this.logCommandText(chalk_1.default.reset(text) + '\n', command); + } + logCommandText(text, command) { + if (this.hide.includes(String(command.index)) || this.hide.includes(command.name)) { + return; + } + const prefix = this.colorText(command, this.getPrefix(command)); + return this.log(prefix + (prefix ? ' ' : ''), text, command); + } + /** + * Logs a global event (e.g. sending signals to processes). + * + * If raw mode is on, then nothing is logged. + */ + logGlobalEvent(text) { + if (this.raw) { + return; + } + this.log(chalk_1.default.reset('-->') + ' ', chalk_1.default.reset(text) + '\n'); + } + /** + * Logs a table from an input object array, like `console.table`. + * + * Each row is a single input item, and they are presented in the input order. + */ + logTable(tableContents) { + // For now, can only print array tables with some content. + if (this.raw || !Array.isArray(tableContents) || !tableContents.length) { + return; + } + let nextColIndex = 0; + const headers = {}; + const contentRows = tableContents.map((row) => { + const rowContents = []; + Object.keys(row).forEach((col) => { + if (!headers[col]) { + headers[col] = { + index: nextColIndex++, + length: col.length, + }; + } + const colIndex = headers[col].index; + const formattedValue = String(row[col] == null ? '' : row[col]); + // Update the column length in case this rows value is longer than the previous length for the column. + headers[col].length = Math.max(formattedValue.length, headers[col].length); + rowContents[colIndex] = formattedValue; + return rowContents; + }); + return rowContents; + }); + const headersFormatted = Object.keys(headers).map((header) => header.padEnd(headers[header].length, ' ')); + if (!headersFormatted.length) { + // No columns exist. + return; + } + const borderRowFormatted = headersFormatted.map((header) => '─'.padEnd(header.length, '─')); + this.logGlobalEvent(`┌─${borderRowFormatted.join('─┬─')}─┐`); + this.logGlobalEvent(`│ ${headersFormatted.join(' │ ')} │`); + this.logGlobalEvent(`├─${borderRowFormatted.join('─┼─')}─┤`); + contentRows.forEach((contentRow) => { + const contentRowFormatted = headersFormatted.map((header, colIndex) => { + // If the table was expanded after this row was processed, it won't have this column. + // Use an empty string in this case. + const col = contentRow[colIndex] || ''; + return col.padEnd(header.length, ' '); + }); + this.logGlobalEvent(`│ ${contentRowFormatted.join(' │ ')} │`); + }); + this.logGlobalEvent(`└─${borderRowFormatted.join('─┴─')}─┘`); + } + log(prefix, text, command) { + if (this.raw) { + return this.emit(command, text); + } + // #70 - replace some ANSI code that would impact clearing lines + text = text.replace(/\u2026/g, '...'); + const lines = text.split('\n').map((line, index, lines) => { + // First line will write prefix only if we finished the last write with a LF. + // Last line won't write prefix because it should be empty. + if (index === 0 || index === lines.length - 1) { + return line; + } + return prefix + line; + }); + if (!this.lastChar || this.lastChar === '\n') { + this.emit(command, prefix); + } + this.lastChar = text[text.length - 1]; + this.emit(command, lines.join('\n')); + } + emit(command, text) { + this.output.next({ command, text }); + } +} +exports.Logger = Logger; |