@genesislcap/pbc-reconciliation-ui 0.0.21 → 0.0.23

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/error-message.js

@@ -1,435 +0,0 @@
-const { format } = require('util')
-const { resolve } = require('path')
-const nameValidator = require('validate-npm-package-name')
-const replaceInfo = require('./replace-info.js')
-const { report } = require('./explain-eresolve.js')
-const log = require('./log-shim')
-
-const messageText = msg => msg.map(line => line.slice(1).join(' ')).join('\n')
-
-const jsonError = (er, npm, { summary, detail }) => {
-  if (npm?.config.loaded && npm.config.get('json')) {
-    return {
-      error: {
-        code: er.code,
-        summary: messageText(summary),
-        detail: messageText(detail),
-      },
-    }
-  }
-}
-
-const errorMessage = (er, npm) => {
-  const short = []
-  const detail = []
-  const files = []
-
-  if (er.message) {
-    er.message = replaceInfo(er.message)
-  }
-  if (er.stack) {
-    er.stack = replaceInfo(er.stack)
-  }
-
-  switch (er.code) {
-    case 'ERESOLVE': {
-      short.push(['ERESOLVE', er.message])
-      detail.push(['', ''])
-      // XXX(display): error messages are logged so we use the logColor since that is based
-      // on stderr. This should be handled solely by the display layer so it could also be
-      // printed to stdout if necessary.
-      const { explanation, file } = report(er, npm.logChalk, npm.noColorChalk)
-      detail.push(['', explanation])
-      files.push(['eresolve-report.txt', file])
-      break
-    }
-
-    case 'ENOLOCK': {
-      const cmd = npm.command || ''
-      short.push([cmd, 'This command requires an existing lockfile.'])
-      detail.push([cmd, 'Try creating one first with: npm i --package-lock-only'])
-      detail.push([cmd, `Original error: ${er.message}`])
-      break
-    }
-
-    case 'ENOAUDIT':
-      short.push(['audit', er.message])
-      break
-
-    case 'ECONNREFUSED':
-      short.push(['', er])
-      detail.push([
-        '',
-        [
-          '\nIf you are behind a proxy, please make sure that the',
-          "'proxy' config is set properly.  See: 'npm help config'",
-        ].join('\n'),
-      ])
-      break
-
-    case 'EACCES':
-    case 'EPERM': {
-      const isCachePath =
-        typeof er.path === 'string' &&
-        npm.config.loaded &&
-        er.path.startsWith(npm.config.get('cache'))
-      const isCacheDest =
-        typeof er.dest === 'string' &&
-        npm.config.loaded &&
-        er.dest.startsWith(npm.config.get('cache'))
-
-      const { isWindows } = require('./is-windows.js')
-
-      if (!isWindows && (isCachePath || isCacheDest)) {
-        // user probably doesn't need this, but still add it to the debug log
-        log.verbose(er.stack)
-        short.push([
-          '',
-          [
-            '',
-            'Your cache folder contains root-owned files, due to a bug in',
-            'previous versions of npm which has since been addressed.',
-            '',
-            'To permanently fix this problem, please run:',
-            `  sudo chown -R ${process.getuid()}:${process.getgid()} ${JSON.stringify(
-              npm.config.get('cache')
-            )}`,
-          ].join('\n'),
-        ])
-      } else {
-        short.push(['', er])
-        detail.push([
-          '',
-          [
-            '\nThe operation was rejected by your operating system.',
-            isWindows
-              /* eslint-disable-next-line max-len */
-              ? "It's possible that the file was already in use (by a text editor or antivirus),\n" +
-                'or that you lack permissions to access it.'
-              /* eslint-disable-next-line max-len */
-              : 'It is likely you do not have the permissions to access this file as the current user',
-            '\nIf you believe this might be a permissions issue, please double-check the',
-            'permissions of the file and its containing directories, or try running',
-            'the command again as root/Administrator.',
-          ].join('\n'),
-        ])
-      }
-      break
-    }
-
-    case 'ENOGIT':
-      short.push(['', er.message])
-      detail.push([
-        '',
-        ['', 'Failed using git.', 'Please check if you have git installed and in your PATH.'].join(
-          '\n'
-        ),
-      ])
-      break
-
-    case 'EJSONPARSE':
-      // Check whether we ran into a conflict in our own package.json
-      if (er.path === resolve(npm.prefix, 'package.json')) {
-        const { isDiff } = require('parse-conflict-json')
-        const txt = require('fs').readFileSync(er.path, 'utf8').replace(/\r\n/g, '\n')
-        if (isDiff(txt)) {
-          detail.push([
-            '',
-            [
-              'Merge conflict detected in your package.json.',
-              '',
-              'Please resolve the package.json conflict and retry.',
-            ].join('\n'),
-          ])
-          break
-        }
-      }
-      short.push(['JSON.parse', er.message])
-      detail.push([
-        'JSON.parse',
-        [
-          'Failed to parse JSON data.',
-          'Note: package.json must be actual JSON, not just JavaScript.',
-        ].join('\n'),
-      ])
-      break
-
-    case 'EOTP':
-    case 'E401':
-      // E401 is for places where we accidentally neglect OTP stuff
-      if (er.code === 'EOTP' || /one-time pass/.test(er.message)) {
-        short.push(['', 'This operation requires a one-time password from your authenticator.'])
-        detail.push([
-          '',
-          [
-            'You can provide a one-time password by passing --otp=<code> to the command you ran.',
-            'If you already provided a one-time password then it is likely that you either typoed',
-            'it, or it timed out. Please try again.',
-          ].join('\n'),
-        ])
-      } else {
-        // npm ERR! code E401
-        // npm ERR! Unable to authenticate, need: Basic
-        const auth =
-          !er.headers || !er.headers['www-authenticate']
-            ? []
-            : er.headers['www-authenticate'].map(au => au.split(/[,\s]+/))[0]
-
-        if (auth.includes('Bearer')) {
-          short.push([
-            '',
-            'Unable to authenticate, your authentication token seems to be invalid.',
-          ])
-          detail.push([
-            '',
-            ['To correct this please trying logging in again with:', '    npm login'].join('\n'),
-          ])
-        } else if (auth.includes('Basic')) {
-          short.push(['', 'Incorrect or missing password.'])
-          detail.push([
-            '',
-            [
-              'If you were trying to login, change your password, create an',
-              'authentication token or enable two-factor authentication then',
-              'that means you likely typed your password in incorrectly.',
-              'Please try again, or recover your password at:',
-              '    https://www.npmjs.com/forgot',
-              '',
-              'If you were doing some other operation then your saved credentials are',
-              'probably out of date. To correct this please try logging in again with:',
-              '    npm login',
-            ].join('\n'),
-          ])
-        } else {
-          short.push(['', er.message || er])
-        }
-      }
-      break
-
-    case 'E404':
-      // There's no need to have 404 in the message as well.
-      short.push(['404', er.message.replace(/^404\s+/, '')])
-      if (er.pkgid && er.pkgid !== '-') {
-        const pkg = er.pkgid.replace(/(?!^)@.*$/, '')
-
-        detail.push(['404', ''])
-        detail.push(['404', '', `'${replaceInfo(er.pkgid)}' is not in this registry.`])
-
-        const valResult = nameValidator(pkg)
-
-        if (!valResult.validForNewPackages) {
-          detail.push(['404', 'This package name is not valid, because', ''])
-
-          const errorsArray = [...(valResult.errors || []), ...(valResult.warnings || [])]
-          errorsArray.forEach((item, idx) => detail.push(['404', ' ' + (idx + 1) + '. ' + item]))
-        }
-
-        detail.push(['404', '\nNote that you can also install from a'])
-        detail.push(['404', 'tarball, folder, http url, or git url.'])
-      }
-      break
-
-    case 'EPUBLISHCONFLICT':
-      short.push(['publish fail', 'Cannot publish over existing version.'])
-      detail.push(['publish fail', "Update the 'version' field in package.json and try again."])
-      detail.push(['publish fail', ''])
-      detail.push(['publish fail', 'To automatically increment version numbers, see:'])
-      detail.push(['publish fail', '    npm help version'])
-      break
-
-    case 'EISGIT':
-      short.push(['git', er.message])
-      short.push(['git', '    ' + er.path])
-      detail.push([
-        'git',
-        ['Refusing to remove it. Update manually,', 'or move it out of the way first.'].join('\n'),
-      ])
-      break
-
-    case 'EBADPLATFORM': {
-      const actual = er.current
-      const expected = { ...er.required }
-      const checkedKeys = []
-      for (const key in expected) {
-        if (Array.isArray(expected[key]) && expected[key].length > 0) {
-          expected[key] = expected[key].join(',')
-          checkedKeys.push(key)
-        } else if (expected[key] === undefined ||
-            Array.isArray(expected[key]) && expected[key].length === 0) {
-          delete expected[key]
-          delete actual[key]
-        } else {
-          checkedKeys.push(key)
-        }
-      }
-
-      const longestKey = Math.max(...checkedKeys.map((key) => key.length))
-      const detailEntry = []
-      for (const key of checkedKeys) {
-        const padding = key.length === longestKey
-          ? 1
-          : 1 + (longestKey - key.length)
-
-        // padding + 1 because 'actual' is longer than 'valid'
-        detailEntry.push(`Valid ${key}:${' '.repeat(padding + 1)}${expected[key]}`)
-        detailEntry.push(`Actual ${key}:${' '.repeat(padding)}${actual[key]}`)
-      }
-
-      short.push([
-        'notsup',
-        [
-          format(
-            'Unsupported platform for %s: wanted %j (current: %j)',
-            er.pkgid,
-            expected,
-            actual
-          ),
-        ].join('\n'),
-      ])
-      detail.push([
-        'notsup',
-        detailEntry.join('\n'),
-      ])
-      break
-    }
-
-    case 'EEXIST':
-      short.push(['', er.message])
-      short.push(['', 'File exists: ' + (er.dest || er.path)])
-      detail.push(['', 'Remove the existing file and try again, or run npm'])
-      detail.push(['', 'with --force to overwrite files recklessly.'])
-      break
-
-    case 'ENEEDAUTH':
-      short.push(['need auth', er.message])
-      detail.push(['need auth', 'You need to authorize this machine using `npm adduser`'])
-      break
-
-    case 'ECONNRESET':
-    case 'ENOTFOUND':
-    case 'ETIMEDOUT':
-    case 'ERR_SOCKET_TIMEOUT':
-    case 'EAI_FAIL':
-      short.push(['network', er.message])
-      detail.push([
-        'network',
-        [
-          'This is a problem related to network connectivity.',
-          'In most cases you are behind a proxy or have bad network settings.',
-          '\nIf you are behind a proxy, please make sure that the',
-          "'proxy' config is set properly.  See: 'npm help config'",
-        ].join('\n'),
-      ])
-      break
-
-    case 'ETARGET':
-      short.push(['notarget', er.message])
-      detail.push([
-        'notarget',
-        [
-          'In most cases you or one of your dependencies are requesting',
-          "a package version that doesn't exist.",
-        ].join('\n'),
-      ])
-      break
-
-    case 'E403':
-      short.push(['403', er.message])
-      detail.push([
-        '403',
-        [
-          'In most cases, you or one of your dependencies are requesting',
-          'a package version that is forbidden by your security policy, or',
-          'on a server you do not have access to.',
-        ].join('\n'),
-      ])
-      break
-
-    case 'EBADENGINE':
-      short.push(['engine', er.message])
-      short.push(['engine', 'Not compatible with your version of node/npm: ' + er.pkgid])
-      detail.push([
-        'notsup',
-        [
-          'Not compatible with your version of node/npm: ' + er.pkgid,
-          'Required: ' + JSON.stringify(er.required),
-          'Actual:   ' +
-            JSON.stringify({
-              npm: npm.version,
-              node: process.version,
-            }),
-        ].join('\n'),
-      ])
-      break
-
-    case 'ENOSPC':
-      short.push(['nospc', er.message])
-      detail.push([
-        'nospc',
-        [
-          'There appears to be insufficient space on your system to finish.',
-          'Clear up some disk space and try again.',
-        ].join('\n'),
-      ])
-      break
-
-    case 'EROFS':
-      short.push(['rofs', er.message])
-      detail.push([
-        'rofs',
-        [
-          'Often virtualized file systems, or other file systems',
-          "that don't support symlinks, give this error.",
-        ].join('\n'),
-      ])
-      break
-
-    case 'ENOENT':
-      short.push(['enoent', er.message])
-      detail.push([
-        'enoent',
-        [
-          'This is related to npm not being able to find a file.',
-          er.file ? "\nCheck if the file '" + er.file + "' is present." : '',
-        ].join('\n'),
-      ])
-      break
-
-    case 'EMISSINGARG':
-    case 'EUNKNOWNTYPE':
-    case 'EINVALIDTYPE':
-    case 'ETOOMANYARGS':
-      short.push(['typeerror', er.stack])
-      detail.push([
-        'typeerror',
-        [
-          'This is an error with npm itself. Please report this error at:',
-          '    https://github.com/npm/cli/issues',
-        ].join('\n'),
-      ])
-      break
-
-    default:
-      short.push(['', er.message || er])
-      if (er.signal) {
-        detail.push(['signal', er.signal])
-      }
-
-      if (er.cmd && Array.isArray(er.args)) {
-        detail.push(['command', ...[er.cmd, ...er.args.map(replaceInfo)]])
-      }
-
-      if (er.stdout) {
-        detail.push(['', er.stdout.trim()])
-      }
-
-      if (er.stderr) {
-        detail.push(['', er.stderr.trim()])
-      }
-
-      break
-  }
-  return { summary: short, detail, files, json: jsonError(er, npm, { summary: short, detail }) }
-}
-
-module.exports = errorMessage

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/exit-handler.js

@@ -1,227 +0,0 @@
-const os = require('os')
-const fs = require('fs')
-
-const log = require('./log-shim.js')
-const errorMessage = require('./error-message.js')
-const replaceInfo = require('./replace-info.js')
-
-let npm = null // set by the cli
-let exitHandlerCalled = false
-let showLogFileError = false
-
-process.on('exit', code => {
-  log.disableProgress()
-
-  // process.emit is synchronous, so the timeEnd handler will run before the
-  // unfinished timer check below
-  process.emit('timeEnd', 'npm')
-
-  const hasLoadedNpm = npm?.config.loaded
-
-  // Unfinished timers can be read before config load
-  if (npm) {
-    for (const [name, timer] of npm.unfinishedTimers) {
-      log.verbose('unfinished npm timer', name, timer)
-    }
-  }
-
-  if (!code) {
-    log.info('ok')
-  } else {
-    log.verbose('code', code)
-  }
-
-  if (!exitHandlerCalled) {
-    process.exitCode = code || 1
-    log.error('', 'Exit handler never called!')
-    // eslint-disable-next-line no-console
-    console.error('')
-    log.error('', 'This is an error with npm itself. Please report this error at:')
-    log.error('', '    <https://github.com/npm/cli/issues>')
-    showLogFileError = true
-  }
-
-  // npm must be loaded to know where the log file was written
-  if (hasLoadedNpm) {
-    // write the timing file now, this might do nothing based on the configs set.
-    // we need to call it here in case it errors so we dont tell the user
-    // about a timing file that doesn't exist
-    npm.writeTimingFile()
-
-    const logsDir = npm.logsDir
-    const logFiles = npm.logFiles
-
-    const timingDir = npm.timingDir
-    const timingFile = npm.timingFile
-
-    const timing = npm.config.get('timing')
-    const logsMax = npm.config.get('logs-max')
-
-    // Determine whether to show log file message and why it is
-    // being shown since in timing mode we always show the log file message
-    const logMethod = showLogFileError ? 'error' : timing ? 'info' : null
-
-    if (logMethod) {
-      if (!npm.silent) {
-        // just a line break if not in silent mode
-        // eslint-disable-next-line no-console
-        console.error('')
-      }
-
-      const message = []
-
-      if (timingFile) {
-        message.push(`Timing info written to: ${timingFile}`)
-      } else if (timing) {
-        message.push(
-          `The timing file was not written due to an error writing to the directory: ${timingDir}`
-        )
-      }
-
-      if (logFiles.length) {
-        message.push(`A complete log of this run can be found in: ${logFiles}`)
-      } else if (logsMax <= 0) {
-        // user specified no log file
-        message.push(`Log files were not written due to the config logs-max=${logsMax}`)
-      } else {
-        // could be an error writing to the directory
-        message.push(
-          `Log files were not written due to an error writing to the directory: ${logsDir}`,
-          'You can rerun the command with `--loglevel=verbose` to see the logs in your terminal'
-        )
-      }
-
-      log[logMethod]('', message.join('\n'))
-    }
-
-    // This removes any listeners npm setup, mostly for tests to avoid max listener warnings
-    npm.unload()
-  }
-
-  // these are needed for the tests to have a clean slate in each test case
-  exitHandlerCalled = false
-  showLogFileError = false
-})
-
-const exitHandler = err => {
-  exitHandlerCalled = true
-
-  log.disableProgress()
-
-  const hasLoadedNpm = npm?.config.loaded
-
-  if (!npm) {
-    err = err || new Error('Exit prior to setting npm in exit handler')
-    // eslint-disable-next-line no-console
-    console.error(err.stack || err.message)
-    return process.exit(1)
-  }
-
-  if (!hasLoadedNpm) {
-    err = err || new Error('Exit prior to config file resolving.')
-    // eslint-disable-next-line no-console
-    console.error(err.stack || err.message)
-  }
-
-  // only show the notification if it finished.
-  if (typeof npm.updateNotification === 'string') {
-    const { level } = log
-    log.level = 'notice'
-    log.notice('', npm.updateNotification)
-    log.level = level
-  }
-
-  let exitCode = process.exitCode || 0
-  let noLogMessage = exitCode !== 0
-  let jsonError
-
-  if (err) {
-    exitCode = 1
-    // if we got a command that just shells out to something else, then it
-    // will presumably print its own errors and exit with a proper status
-    // code if there's a problem.  If we got an error with a code=0, then...
-    // something else went wrong along the way, so maybe an npm problem?
-    const isShellout = npm.isShellout
-    const quietShellout = isShellout && typeof err.code === 'number' && err.code
-    if (quietShellout) {
-      exitCode = err.code
-      noLogMessage = true
-    } else if (typeof err === 'string') {
-      // XXX: we should stop throwing strings
-      log.error('', err)
-      noLogMessage = true
-    } else if (!(err instanceof Error)) {
-      log.error('weird error', err)
-      noLogMessage = true
-    } else {
-      if (!err.code) {
-        const matchErrorCode = err.message.match(/^(?:Error: )?(E[A-Z]+)/)
-        err.code = matchErrorCode && matchErrorCode[1]
-      }
-
-      for (const k of ['type', 'stack', 'statusCode', 'pkgid']) {
-        const v = err[k]
-        if (v) {
-          log.verbose(k, replaceInfo(v))
-        }
-      }
-
-      log.verbose('cwd', process.cwd())
-      log.verbose('', os.type() + ' ' + os.release())
-      log.verbose('node', process.version)
-      log.verbose('npm ', 'v' + npm.version)
-
-      for (const k of ['code', 'syscall', 'file', 'path', 'dest', 'errno']) {
-        const v = err[k]
-        if (v) {
-          log.error(k, v)
-        }
-      }
-
-      const { summary, detail, json, files = [] } = errorMessage(err, npm)
-      jsonError = json
-
-      for (let [file, content] of files) {
-        file = `${npm.logPath}${file}`
-        content = `'Log files:\n${npm.logFiles.join('\n')}\n\n${content.trim()}\n`
-        try {
-          fs.writeFileSync(file, content)
-          detail.push(['', `\n\nFor a full report see:\n${file}`])
-        } catch (logFileErr) {
-          log.warn('', `Could not write error message to ${file} due to ${logFileErr}`)
-        }
-      }
-
-      for (const errline of [...summary, ...detail]) {
-        log.error(...errline)
-      }
-
-      if (typeof err.errno === 'number') {
-        exitCode = err.errno
-      } else if (typeof err.code === 'number') {
-        exitCode = err.code
-      }
-    }
-  }
-
-  if (hasLoadedNpm) {
-    npm.flushOutput(jsonError)
-  }
-
-  log.verbose('exit', exitCode || 0)
-
-  showLogFileError = (hasLoadedNpm && npm.silent) || noLogMessage
-    ? false
-    : !!exitCode
-
-  // explicitly call process.exit now so we don't hang on things like the
-  // update notifier, also flush stdout/err beforehand because process.exit doesn't
-  // wait for that to happen.
-  let flushed = 0
-  const flush = [process.stderr, process.stdout]
-  const exit = () => ++flushed === flush.length && process.exit(exitCode)
-  flush.forEach((f) => f.write('', exit))
-}
-
-module.exports = exitHandler
-module.exports.setNpm = n => (npm = n)