????
Your IP : 18.219.43.26
const { inspect } = require('util')
const npmlog = require('npmlog')
const log = require('./log-shim.js')
const { explain } = require('./explain-eresolve.js')
const originalCustomInspect = Symbol('npm.display.original.util.inspect.custom')
// These are most assuredly not a mistake
// https://eslint.org/docs/latest/rules/no-control-regex
/* eslint-disable no-control-regex */
// \x00 through \x1f, \x7f through \x9f, not including \x09 \x0a \x0b \x0d
const hasC01 = /[\x00-\x08\x0c\x0e-\x1f\x7f-\x9f]/
// Allows everything up to '[38;5;255m' in 8 bit notation
const allowedSGR = /^\[[0-9;]{0,8}m/
// '[38;5;255m'.length
const sgrMaxLen = 10
// Strips all ANSI C0 and C1 control characters (except for SGR up to 8 bit)
function stripC01 (str) {
if (!hasC01.test(str)) {
return str
}
let result = ''
for (let i = 0; i < str.length; i++) {
const char = str[i]
const code = char.charCodeAt(0)
if (!hasC01.test(char)) {
// Most characters are in this set so continue early if we can
result = `${result}${char}`
} else if (code === 27 && allowedSGR.test(str.slice(i + 1, i + sgrMaxLen + 1))) {
// \x1b with allowed SGR
result = `${result}\x1b`
} else if (code <= 31) {
// escape all other C0 control characters besides \x7f
result = `${result}^${String.fromCharCode(code + 64)}`
} else {
// hasC01 ensures this is now a C1 control character or \x7f
result = `${result}^${String.fromCharCode(code - 64)}`
}
}
return result
}
class Display {
#chalk = null
constructor () {
// pause by default until config is loaded
this.on()
log.pause()
}
static clean (output) {
if (typeof output === 'string') {
// Strings are cleaned inline
return stripC01(output)
}
if (!output || typeof output !== 'object') {
// Numbers, booleans, null all end up here and don't need cleaning
return output
}
// output && typeof output === 'object'
// We can't use hasOwn et al for detecting the original but we can use it
// for detecting the properties we set via defineProperty
if (
output[inspect.custom] &&
(!Object.hasOwn(output, originalCustomInspect))
) {
// Save the old one if we didn't already do it.
Object.defineProperty(output, originalCustomInspect, {
value: output[inspect.custom],
writable: true,
})
}
if (!Object.hasOwn(output, originalCustomInspect)) {
// Put a dummy one in for when we run multiple times on the same object
Object.defineProperty(output, originalCustomInspect, {
value: function () {
return this
},
writable: true,
})
}
// Set the custom inspect to our own function
Object.defineProperty(output, inspect.custom, {
value: function () {
const toClean = this[originalCustomInspect]()
// Custom inspect can return things other than objects, check type again
if (typeof toClean === 'string') {
// Strings are cleaned inline
return stripC01(toClean)
}
if (!toClean || typeof toClean !== 'object') {
// Numbers, booleans, null all end up here and don't need cleaning
return toClean
}
return stripC01(inspect(toClean, { customInspect: false }))
},
writable: true,
})
return output
}
on () {
process.on('log', this.#logHandler)
}
off () {
process.off('log', this.#logHandler)
// Unbalanced calls to enable/disable progress
// will leave change listeners on the tracker
// This pretty much only happens in tests but
// this removes the event emitter listener warnings
log.tracker.removeAllListeners()
}
load (config) {
const {
color,
chalk,
timing,
loglevel,
unicode,
progress,
silent,
heading = 'npm',
} = config
this.#chalk = chalk
// npmlog is still going away someday, so this is a hack to dynamically
// set the loglevel of timing based on the timing flag, instead of making
// a breaking change to npmlog. The result is that timing logs are never
// shown except when the --timing flag is set. We also need to change
// the index of the silly level since otherwise it is set to -Infinity
// and we can't go any lower than that. silent is still set to Infinify
// because we DO want silent to hide timing levels. This allows for the
// special case of getting timing information while hiding all CLI output
// in order to get perf information that might be affected by writing to
// a terminal. XXX(npmlog): this will be removed along with npmlog
log.levels.silly = -10000
log.levels.timing = log.levels[loglevel] + (timing ? 1 : -1)
log.level = loglevel
log.heading = heading
if (color) {
log.enableColor()
} else {
log.disableColor()
}
if (unicode) {
log.enableUnicode()
} else {
log.disableUnicode()
}
// if it's silent, don't show progress
if (progress && !silent) {
log.enableProgress()
} else {
log.disableProgress()
}
// Resume displaying logs now that we have config
log.resume()
}
log (...args) {
this.#logHandler(...args)
}
#logHandler = (level, ...args) => {
try {
this.#log(level, ...args)
} catch (ex) {
try {
// if it crashed once, it might again!
this.#npmlog('verbose', `attempt to log ${inspect(args)} crashed`, ex)
} catch (ex2) {
// eslint-disable-next-line no-console
console.error(`attempt to log ${inspect(args)} crashed`, ex, ex2)
}
}
}
#log (...args) {
return this.#eresolveWarn(...args) || this.#npmlog(...args)
}
// Explicitly call these on npmlog and not log shim
// This is the final place we should call npmlog before removing it.
#npmlog (level, ...args) {
npmlog[level](...args.map(Display.clean))
}
// Also (and this is a really inexcusable kludge), we patch the
// log.warn() method so that when we see a peerDep override
// explanation from Arborist, we can replace the object with a
// highly abbreviated explanation of what's being overridden.
#eresolveWarn (level, heading, message, expl) {
if (level === 'warn' &&
heading === 'ERESOLVE' &&
expl && typeof expl === 'object'
) {
this.#npmlog(level, heading, message)
this.#npmlog(level, '', explain(expl, this.#chalk, 2))
// Return true to short circuit other log in chain
return true
}
}
}
module.exports = Display