pxnpm 5.0.0 → 6.0.1

package/dist/node_modules/node-gyp/lib/install.js

@@ -1,26 +1,21 @@
 'use strict'
 
-const fs = require('graceful-fs')
+const { createWriteStream, promises: fs } = require('graceful-fs')
 const os = require('os')
 const { backOff } = require('exponential-backoff')
-const rm = require('rimraf')
 const tar = require('tar')
 const path = require('path')
-const util = require('util')
-const stream = require('stream')
+const { Transform, promises: { pipeline } } = require('stream')
 const crypto = require('crypto')
-const log = require('npmlog')
+const log = require('./log')
 const semver = require('semver')
-const fetch = require('make-fetch-happen')
+const { download } = require('./download')
 const processRelease = require('./process-release')
-const win = process.platform === 'win32'
-const streamPipeline = util.promisify(stream.pipeline)
 
-/**
- * @param {typeof import('graceful-fs')} fs
- */
+const win = process.platform === 'win32'
 
-async function install (fs, gyp, argv) {
+async function install (gyp, argv) {
+  log.stdout()
   const release = processRelease(argv, gyp, process.version, process.release)
   // Detecting target_arch based on logic from create-cnfig-gyp.js. Used on Windows only.
   const arch = win ? (gyp.opts.target_arch || gyp.opts.arch || process.arch || 'ia32') : ''
@@ -60,7 +55,7 @@ async function install (fs, gyp, argv) {
   if (gyp.opts.ensure) {
     log.verbose('install', '--ensure was passed, so won\'t reinstall if already installed')
     try {
-      await fs.promises.stat(devDir)
+      await fs.stat(devDir)
     } catch (err) {
       if (err.code === 'ENOENT') {
         log.verbose('install', 'version not already installed, continuing with install', release.version)
@@ -78,7 +73,7 @@ async function install (fs, gyp, argv) {
     const installVersionFile = path.resolve(devDir, 'installVersion')
     let installVersion = 0
     try {
-      const ver = await fs.promises.readFile(installVersionFile, 'ascii')
+      const ver = await fs.readFile(installVersionFile, 'ascii')
       installVersion = parseInt(ver, 10) || 0
     } catch (err) {
       if (err.code !== 'ENOENT') {
@@ -100,7 +95,7 @@ async function install (fs, gyp, argv) {
       log.verbose('on Windows; need to check node.lib')
       const nodeLibPath = path.resolve(devDir, arch, 'node.lib')
       try {
-        await fs.promises.stat(nodeLibPath)
+        await fs.stat(nodeLibPath)
       } catch (err) {
         if (err.code === 'ENOENT') {
           log.verbose('install', `version not already installed for ${arch}, continuing with install`, release.version)
@@ -126,12 +121,12 @@ async function install (fs, gyp, argv) {
 
   async function copyDirectory (src, dest) {
     try {
-      await fs.promises.stat(src)
+      await fs.stat(src)
     } catch {
       throw new Error(`Missing source directory for copy: ${src}`)
     }
-    await fs.promises.mkdir(dest, { recursive: true })
-    const entries = await fs.promises.readdir(src, { withFileTypes: true })
+    await fs.mkdir(dest, { recursive: true })
+    const entries = await fs.readdir(src, { withFileTypes: true })
     for (const entry of entries) {
       if (entry.isDirectory()) {
         await copyDirectory(path.join(src, entry.name), path.join(dest, entry.name))
@@ -140,12 +135,12 @@ async function install (fs, gyp, argv) {
         // Windows so use an exponential backoff to resolve collisions
         await backOff(async () => {
           try {
-            await fs.promises.copyFile(path.join(src, entry.name), path.join(dest, entry.name))
+            await fs.copyFile(path.join(src, entry.name), path.join(dest, entry.name))
           } catch (err) {
             // if ensure, check if file already exists and that's good enough
             if (gyp.opts.ensure && err.code === 'EBUSY') {
               try {
-                await fs.promises.stat(path.join(dest, entry.name))
+                await fs.stat(path.join(dest, entry.name))
                 return
               } catch {}
             }
@@ -163,7 +158,7 @@ async function install (fs, gyp, argv) {
 
     // first create the dir for the node dev files
     try {
-      const created = await fs.promises.mkdir(devDir, { recursive: true })
+      const created = await fs.mkdir(devDir, { recursive: true })
 
       if (created) {
         log.verbose('created devDir', created)
@@ -208,7 +203,7 @@ async function install (fs, gyp, argv) {
     // on Windows there can be file errors from tar if parallel installs
     // are happening (not uncommon with multiple native modules) so
     // extract the tarball to a temp directory first and then copy over
-    const tarExtractDir = win ? await fs.promises.mkdtemp(path.join(os.tmpdir(), 'node-gyp-tmp-')) : devDir
+    const tarExtractDir = win ? await fs.mkdtemp(path.join(os.tmpdir(), 'node-gyp-tmp-')) : devDir
 
     try {
       if (shouldDownloadTarball) {
@@ -228,7 +223,7 @@ async function install (fs, gyp, argv) {
               throw new Error(`${res.status} response downloading ${release.tarballUrl}`)
             }
 
-            await streamPipeline(
+            await pipeline(
               res.body,
               // content checksum
               new ShaSum((_, checksum) => {
@@ -267,7 +262,7 @@ async function install (fs, gyp, argv) {
       // need to download node.lib
         ...(win ? [downloadNodeLib()] : []),
         // write the "installVersion" file
-        fs.promises.writeFile(installVersionPath, gyp.package.installVersion + '\n'),
+        fs.writeFile(installVersionPath, gyp.package.installVersion + '\n'),
         // Only download SHASUMS.txt if we downloaded something in need of SHA verification
         ...(!tarPath || win ? [downloadShasums()] : [])
       ])
@@ -289,7 +284,7 @@ async function install (fs, gyp, argv) {
       if (tarExtractDir !== devDir) {
         try {
           // try to cleanup temp dir
-          await util.promisify(rm)(tarExtractDir)
+          await fs.rm(tarExtractDir, { recursive: true })
         } catch {
           log.warn('failed to clean up temp tarball extract directory')
         }
@@ -329,7 +324,7 @@ async function install (fs, gyp, argv) {
       log.verbose(name, 'dir', dir)
       log.verbose(name, 'url', libUrl)
 
-      await fs.promises.mkdir(dir, { recursive: true })
+      await fs.mkdir(dir, { recursive: true })
       log.verbose('streaming', name, 'to:', targetLibPath)
 
       const res = await download(gyp, libUrl)
@@ -339,13 +334,13 @@ async function install (fs, gyp, argv) {
         throw new Error(`${res.status} status code downloading ${name}`)
       }
 
-      return streamPipeline(
+      return pipeline(
         res.body,
         new ShaSum((_, checksum) => {
           contentShasums[libPath] = checksum
           log.verbose('content checksum', libPath, checksum)
         }),
-        fs.createWriteStream(targetLibPath)
+        createWriteStream(targetLibPath)
       )
     } // downloadNodeLib()
   } // go()
@@ -363,7 +358,7 @@ async function install (fs, gyp, argv) {
   async function rollback (err) {
     log.warn('install', 'got an error, rolling back install')
     // roll-back the install if anything went wrong
-    await util.promisify(gyp.commands.remove)([release.versionDir])
+    await gyp.commands.remove([release.versionDir])
     throw err
   }
 
@@ -394,11 +389,11 @@ async function install (fs, gyp, argv) {
       log.verbose('tmpdir == cwd', 'automatically will remove dev files after to save disk space')
       gyp.todo.push({ name: 'remove', args: argv })
     }
-    return util.promisify(gyp.commands.install)([noretry].concat(argv))
+    return gyp.commands.install([noretry].concat(argv))
   }
 }
 
-class ShaSum extends stream.Transform {
+class ShaSum extends Transform {
   constructor (callback) {
     super()
     this._callback = callback
@@ -416,43 +411,5 @@ class ShaSum extends stream.Transform {
   }
 }
 
-async function download (gyp, url) {
-  log.http('GET', url)
-
-  const requestOpts = {
-    headers: {
-      'User-Agent': `node-gyp v${gyp.version} (node ${process.version})`,
-      Connection: 'keep-alive'
-    },
-    proxy: gyp.opts.proxy,
-    noProxy: gyp.opts.noproxy
-  }
-
-  const cafile = gyp.opts.cafile
-  if (cafile) {
-    requestOpts.ca = await readCAFile(cafile)
-  }
-
-  const res = await fetch(url, requestOpts)
-  log.http(res.status, res.url)
-
-  return res
-}
-
-async function readCAFile (filename) {
-  // The CA file can contain multiple certificates so split on certificate
-  // boundaries.  [\S\s]*? is used to match everything including newlines.
-  const ca = await fs.promises.readFile(filename, 'utf8')
-  const re = /(-----BEGIN CERTIFICATE-----[\S\s]*?-----END CERTIFICATE-----)/g
-  return ca.match(re)
-}
-
-module.exports = function (gyp, argv, callback) {
-  install(fs, gyp, argv).then(callback.bind(undefined, null), callback)
-}
-module.exports.test = {
-  download,
-  install,
-  readCAFile
-}
+module.exports = install
 module.exports.usage = 'Install node development files for the specified node version.'

package/dist/node_modules/node-gyp/lib/list.js

@@ -1,26 +1,25 @@
 'use strict'
 
-const fs = require('graceful-fs')
-const log = require('npmlog')
+const fs = require('graceful-fs').promises
+const log = require('./log')
 
-function list (gyp, args, callback) {
-  var devDir = gyp.devDir
+async function list (gyp, args) {
+  const devDir = gyp.devDir
   log.verbose('list', 'using node-gyp dir:', devDir)
 
-  fs.readdir(devDir, onreaddir)
-
-  function onreaddir (err, versions) {
-    if (err && err.code !== 'ENOENT') {
-      return callback(err)
+  let versions = []
+  try {
+    const dir = await fs.readdir(devDir)
+    if (Array.isArray(dir)) {
+      versions = dir.filter((v) => v !== 'current')
     }
-
-    if (Array.isArray(versions)) {
-      versions = versions.filter(function (v) { return v !== 'current' })
-    } else {
-      versions = []
+  } catch (err) {
+    if (err && err.code !== 'ENOENT') {
+      throw err
     }
-    callback(null, versions)
   }
+
+  return versions
 }
 
 module.exports = list

package/dist/node_modules/node-gyp/lib/log.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const { log } = require('proc-log')
+const { format } = require('util')
+
+// helper to emit log messages with a predefined prefix
+const withPrefix = (prefix) => log.LEVELS.reduce((acc, level) => {
+  acc[level] = (...args) => log[level](prefix, ...args)
+  return acc
+}, {})
+
+// very basic ansi color generator
+const COLORS = {
+  wrap: (str, colors) => {
+    const codes = colors.filter(c => typeof c === 'number')
+    return `\x1b[${codes.join(';')}m${str}\x1b[0m`
+  },
+  inverse: 7,
+  fg: {
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37
+  },
+  bg: {
+    black: 40,
+    red: 41,
+    green: 42,
+    yellow: 43,
+    blue: 44,
+    magenta: 45,
+    cyan: 46,
+    white: 47
+  }
+}
+
+class Logger {
+  #buffer = []
+  #paused = null
+  #level = null
+  #stream = null
+
+  // ordered from loudest to quietest
+  #levels = [{
+    id: 'silly',
+    display: 'sill',
+    style: { inverse: true }
+  }, {
+    id: 'verbose',
+    display: 'verb',
+    style: { fg: 'cyan', bg: 'black' }
+  }, {
+    id: 'info',
+    style: { fg: 'green' }
+  }, {
+    id: 'http',
+    style: { fg: 'green', bg: 'black' }
+  }, {
+    id: 'notice',
+    style: { fg: 'cyan', bg: 'black' }
+  }, {
+    id: 'warn',
+    display: 'WARN',
+    style: { fg: 'black', bg: 'yellow' }
+  }, {
+    id: 'error',
+    display: 'ERR!',
+    style: { fg: 'red', bg: 'black' }
+  }]
+
+  constructor (stream) {
+    process.on('log', (...args) => this.#onLog(...args))
+    this.#levels = new Map(this.#levels.map((level, index) => [level.id, { ...level, index }]))
+    this.level = 'info'
+    this.stream = stream
+    log.pause()
+  }
+
+  get stream () {
+    return this.#stream
+  }
+
+  set stream (stream) {
+    this.#stream = stream
+  }
+
+  get level () {
+    return this.#levels.get(this.#level) ?? null
+  }
+
+  set level (level) {
+    this.#level = this.#levels.get(level)?.id ?? null
+  }
+
+  isVisible (level) {
+    return this.level?.index <= this.#levels.get(level)?.index ?? -1
+  }
+
+  #onLog (...args) {
+    const [level] = args
+
+    if (level === 'pause') {
+      this.#paused = true
+      return
+    }
+
+    if (level === 'resume') {
+      this.#paused = false
+      this.#buffer.forEach((b) => this.#log(...b))
+      this.#buffer.length = 0
+      return
+    }
+
+    if (this.#paused) {
+      this.#buffer.push(args)
+      return
+    }
+
+    this.#log(...args)
+  }
+
+  #color (str, { fg, bg, inverse }) {
+    if (!this.#stream?.isTTY) {
+      return str
+    }
+
+    return COLORS.wrap(str, [
+      COLORS.fg[fg],
+      COLORS.bg[bg],
+      inverse && COLORS.inverse
+    ])
+  }
+
+  #log (levelId, msgPrefix, ...args) {
+    if (!this.isVisible(levelId) || typeof this.#stream?.write !== 'function') {
+      return
+    }
+
+    const level = this.#levels.get(levelId)
+
+    const prefixParts = [
+      this.#color('gyp', { fg: 'white', bg: 'black' }),
+      this.#color(level.display ?? level.id, level.style)
+    ]
+    if (msgPrefix) {
+      prefixParts.push(this.#color(msgPrefix, { fg: 'magenta' }))
+    }
+
+    const prefix = prefixParts.join(' ').trim() + ' '
+    const lines = format(...args).split(/\r?\n/).map(l => prefix + l.trim())
+
+    this.#stream.write(lines.join('\n') + '\n')
+  }
+}
+
+// used to suppress logs in tests
+const NULL_LOGGER = !!process.env.NODE_GYP_NULL_LOGGER
+
+module.exports = {
+  logger: new Logger(NULL_LOGGER ? null : process.stderr),
+  stdout: NULL_LOGGER ? () => {} : (...args) => console.log(...args),
+  withPrefix,
+  ...log
+}