pxnpm 5.0.0 → 6.0.0

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

@@ -1,47 +1,62 @@
 'use strict'
 
-const fs = require('graceful-fs')
+const { promises: fs, readFileSync } = require('graceful-fs')
 const path = require('path')
-const log = require('npmlog')
+const log = require('./log')
 const os = require('os')
 const processRelease = require('./process-release')
 const win = process.platform === 'win32'
 const findNodeDirectory = require('./find-node-directory')
-const createConfigGypi = require('./create-config-gypi')
-const msgFormat = require('util').format
-var findPython = require('./find-python')
-if (win) {
-  var findVisualStudio = require('./find-visualstudio')
-}
-
-function configure (gyp, argv, callback) {
-  var python
-  var buildDir = path.resolve('build')
-  var buildBinsDir = path.join(buildDir, 'node_gyp_bins')
-  var configNames = ['config.gypi', 'common.gypi']
-  var configs = []
-  var nodeDir
-  var release = processRelease(argv, gyp, process.version, process.release)
-
-  findPython(gyp.opts.python, function (err, found) {
-    if (err) {
-      callback(err)
-    } else {
-      python = found
-      getNodeDir()
-    }
-  })
-
-  function getNodeDir () {
+const { createConfigGypi } = require('./create-config-gypi')
+const { format: msgFormat } = require('util')
+const { findAccessibleSync } = require('./util')
+const { findPython } = require('./find-python')
+const { findVisualStudio } = win ? require('./find-visualstudio') : {}
+
+const majorRe = /^#define NODE_MAJOR_VERSION (\d+)/m
+const minorRe = /^#define NODE_MINOR_VERSION (\d+)/m
+const patchRe = /^#define NODE_PATCH_VERSION (\d+)/m
+
+async function configure (gyp, argv) {
+  const buildDir = path.resolve('build')
+  const configNames = ['config.gypi', 'common.gypi']
+  const configs = []
+  let nodeDir
+  const release = processRelease(argv, gyp, process.version, process.release)
+
+  const python = await findPython(gyp.opts.python)
+  return getNodeDir()
+
+  async function getNodeDir () {
     // 'python' should be set by now
     process.env.PYTHON = python
 
+    if (!gyp.opts.nodedir &&
+        process.config.variables.use_prefix_to_find_headers) {
+      // check if the headers can be found using the prefix specified
+      // at build time. Use them if they match the version expected
+      const prefix = process.config.variables.node_prefix
+      let availVersion
+      try {
+        const nodeVersionH = readFileSync(path.join(prefix,
+          'include', 'node', 'node_version.h'), { encoding: 'utf8' })
+        const major = nodeVersionH.match(majorRe)[1]
+        const minor = nodeVersionH.match(minorRe)[1]
+        const patch = nodeVersionH.match(patchRe)[1]
+        availVersion = major + '.' + minor + '.' + patch
+      } catch {}
+      if (availVersion === release.version) {
+        // ok version matches, use the headers
+        gyp.opts.nodedir = prefix
+        log.verbose('using local node headers based on prefix',
+          'setting nodedir to ' + gyp.opts.nodedir)
+      }
+    }
+
     if (gyp.opts.nodedir) {
       // --nodedir was specified. use that for the dev files
       nodeDir = gyp.opts.nodedir.replace(/^~/, os.homedir())
-
       log.verbose('get node dir', 'compiling against specified --nodedir dev files: %s', nodeDir)
-      createBuildDir()
     } else {
       // if no --nodedir specified, ensure node dependencies are installed
       if ('v' + release.version !== process.version) {
@@ -54,108 +69,86 @@ function configure (gyp, argv, callback) {
 
       if (!release.semver) {
         // could not parse the version string with semver
-        return callback(new Error('Invalid version number: ' + release.version))
+        throw new Error('Invalid version number: ' + release.version)
       }
 
       // If the tarball option is set, always remove and reinstall the headers
       // into devdir. Otherwise only install if they're not already there.
       gyp.opts.ensure = !gyp.opts.tarball
 
-      gyp.commands.install([release.version], function (err) {
-        if (err) {
-          return callback(err)
-        }
-        log.verbose('get node dir', 'target node version installed:', release.versionDir)
-        nodeDir = path.resolve(gyp.devDir, release.versionDir)
-        createBuildDir()
-      })
+      await gyp.commands.install([release.version])
+
+      log.verbose('get node dir', 'target node version installed:', release.versionDir)
+      nodeDir = path.resolve(gyp.devDir, release.versionDir)
     }
+
+    return createBuildDir()
   }
 
-  function createBuildDir () {
+  async function createBuildDir () {
     log.verbose('build dir', 'attempting to create "build" dir: %s', buildDir)
 
-    const deepestBuildDirSubdirectory = win ? buildDir : buildBinsDir
-    fs.mkdir(deepestBuildDirSubdirectory, { recursive: true }, function (err, isNew) {
-      if (err) {
-        return callback(err)
-      }
-      log.verbose(
-        'build dir', '"build" dir needed to be created?', isNew ? 'Yes' : 'No'
-      )
-      if (win) {
-        findVisualStudio(release.semver, gyp.opts.msvs_version,
-          createConfigFile)
-      } else {
-        createPythonSymlink()
-        createConfigFile()
+    const isNew = await fs.mkdir(buildDir, { recursive: true })
+    log.verbose(
+      'build dir', '"build" dir needed to be created?', isNew ? 'Yes' : 'No'
+    )
+    if (win) {
+      let usingMakeGenerator = false
+      for (let i = argv.length - 1; i >= 0; --i) {
+        const arg = argv[i]
+        if (arg === '-f' || arg === '--format') {
+          const format = argv[i + 1]
+          if (typeof format === 'string' && format.startsWith('make')) {
+            usingMakeGenerator = true
+            break
+          }
+        } else if (arg.startsWith('--format=make')) {
+          usingMakeGenerator = true
+          break
+        }
       }
-    })
-  }
-
-  function createPythonSymlink () {
-    const symlinkDestination = path.join(buildBinsDir, 'python3')
-
-    log.verbose('python symlink', `creating symlink to "${python}" at "${symlinkDestination}"`)
-
-    fs.unlink(symlinkDestination, function (err) {
-      if (err && err.code !== 'ENOENT') {
-        log.verbose('python symlink', 'error when attempting to remove existing symlink')
-        log.verbose('python symlink', err.stack, 'errno: ' + err.errno)
+      let vsInfo = {}
+      if (!usingMakeGenerator) {
+        vsInfo = await findVisualStudio(release.semver, gyp.opts['msvs-version'])
       }
-      fs.symlink(python, symlinkDestination, function (err) {
-        if (err) {
-          log.verbose('python symlink', 'error when attempting to create Python symlink')
-          log.verbose('python symlink', err.stack, 'errno: ' + err.errno)
-        }
-      })
-    })
+      return createConfigFile(vsInfo)
+    }
+    return createConfigFile(null)
   }
 
-  function createConfigFile (err, vsInfo) {
-    if (err) {
-      return callback(err)
-    }
-    if (process.platform === 'win32') {
+  async function createConfigFile (vsInfo) {
+    if (win) {
       process.env.GYP_MSVS_VERSION = Math.min(vsInfo.versionYear, 2015)
       process.env.GYP_MSVS_OVERRIDE_PATH = vsInfo.path
     }
-    createConfigGypi({ gyp, buildDir, nodeDir, vsInfo }).then(configPath => {
-      configs.push(configPath)
-      findConfigs()
-    }).catch(err => {
-      callback(err)
-    })
+    const configPath = await createConfigGypi({ gyp, buildDir, nodeDir, vsInfo, python })
+    configs.push(configPath)
+    return findConfigs()
   }
 
-  function findConfigs () {
-    var name = configNames.shift()
+  async function findConfigs () {
+    const name = configNames.shift()
     if (!name) {
       return runGyp()
     }
-    var fullPath = path.resolve(name)
 
+    const fullPath = path.resolve(name)
     log.verbose(name, 'checking for gypi file: %s', fullPath)
-    fs.stat(fullPath, function (err) {
-      if (err) {
-        if (err.code === 'ENOENT') {
-          findConfigs() // check next gypi filename
-        } else {
-          callback(err)
-        }
-      } else {
-        log.verbose(name, 'found gypi file')
-        configs.push(fullPath)
-        findConfigs()
+    try {
+      await fs.stat(fullPath)
+      log.verbose(name, 'found gypi file')
+      configs.push(fullPath)
+    } catch (err) {
+      // ENOENT will check next gypi filename
+      if (err.code !== 'ENOENT') {
+        throw err
       }
-    })
-  }
-
-  function runGyp (err) {
-    if (err) {
-      return callback(err)
     }
 
+    return findConfigs()
+  }
+
+  async function runGyp () {
     if (!~argv.indexOf('-f') && !~argv.indexOf('--format')) {
       if (win) {
         log.verbose('gyp', 'gyp format was not specified; forcing "msvs"')
@@ -175,11 +168,13 @@ function configure (gyp, argv, callback) {
 
     // For AIX and z/OS we need to set up the path to the exports file
     // which contains the symbols needed for linking.
-    var nodeExpFile
+    let nodeExpFile
+    let nodeRootDir
+    let candidates
+    let logprefix = 'find exports file'
     if (process.platform === 'aix' || process.platform === 'os390' || process.platform === 'os400') {
-      var ext = process.platform === 'os390' ? 'x' : 'exp'
-      var nodeRootDir = findNodeDirectory()
-      var candidates
+      const ext = process.platform === 'os390' ? 'x' : 'exp'
+      nodeRootDir = findNodeDirectory()
 
       if (process.platform === 'aix' || process.platform === 'os400') {
         candidates = [
@@ -202,24 +197,23 @@ function configure (gyp, argv, callback) {
         })
       }
 
-      var logprefix = 'find exports file'
       nodeExpFile = findAccessibleSync(logprefix, nodeRootDir, candidates)
       if (nodeExpFile !== undefined) {
         log.verbose(logprefix, 'Found exports file: %s', nodeExpFile)
       } else {
-        var msg = msgFormat('Could not find node.%s file in %s', ext, nodeRootDir)
+        const msg = msgFormat('Could not find node.%s file in %s', ext, nodeRootDir)
         log.error(logprefix, 'Could not find exports file')
-        return callback(new Error(msg))
+        throw new Error(msg)
       }
     }
 
     // For z/OS we need to set up the path to zoslib include directory,
     // which contains headers included in v8config.h.
-    var zoslibIncDir
+    let zoslibIncDir
     if (process.platform === 'os390') {
       logprefix = "find zoslib's zos-base.h:"
       let msg
-      var zoslibIncPath = process.env.ZOSLIB_INCLUDES
+      let zoslibIncPath = process.env.ZOSLIB_INCLUDES
       if (zoslibIncPath) {
         zoslibIncPath = findAccessibleSync(logprefix, zoslibIncPath, ['zos-base.h'])
         if (zoslibIncPath === undefined) {
@@ -247,114 +241,88 @@ function configure (gyp, argv, callback) {
       } else if (release.version.split('.')[0] >= 16) {
         // zoslib is only shipped in Node v16 and above.
         log.error(logprefix, msg)
-        return callback(new Error(msg))
+        throw new Error(msg)
       }
     }
 
     // this logic ported from the old `gyp_addon` python file
-    var gypScript = path.resolve(__dirname, '..', 'gyp', 'gyp_main.py')
-    var addonGypi = path.resolve(__dirname, '..', 'addon.gypi')
-    var commonGypi = path.resolve(nodeDir, 'include/node/common.gypi')
-    fs.stat(commonGypi, function (err) {
-      if (err) {
-        commonGypi = path.resolve(nodeDir, 'common.gypi')
-      }
+    const gypScript = path.resolve(__dirname, '..', 'gyp', 'gyp_main.py')
+    const addonGypi = path.resolve(__dirname, '..', 'addon.gypi')
+    let commonGypi = path.resolve(nodeDir, 'include/node/common.gypi')
+    try {
+      await fs.stat(commonGypi)
+    } catch (err) {
+      commonGypi = path.resolve(nodeDir, 'common.gypi')
+    }
 
-      var outputDir = 'build'
-      if (win) {
-        // Windows expects an absolute path
-        outputDir = buildDir
-      }
-      var nodeGypDir = path.resolve(__dirname, '..')
-
-      var nodeLibFile = path.join(nodeDir,
-        !gyp.opts.nodedir ? '<(target_arch)' : '$(Configuration)',
-        release.name + '.lib')
-
-      argv.push('-I', addonGypi)
-      argv.push('-I', commonGypi)
-      argv.push('-Dlibrary=shared_library')
-      argv.push('-Dvisibility=default')
-      argv.push('-Dnode_root_dir=' + nodeDir)
-      if (process.platform === 'aix' || process.platform === 'os390' || process.platform === 'os400') {
-        argv.push('-Dnode_exp_file=' + nodeExpFile)
-        if (process.platform === 'os390' && zoslibIncDir) {
-          argv.push('-Dzoslib_include_dir=' + zoslibIncDir)
-        }
-      }
-      argv.push('-Dnode_gyp_dir=' + nodeGypDir)
+    let outputDir = 'build'
+    if (win) {
+      // Windows expects an absolute path
+      outputDir = buildDir
+    }
+    const nodeGypDir = path.resolve(__dirname, '..')
 
-      // Do this to keep Cygwin environments happy, else the unescaped '\' gets eaten up,
-      // resulting in bad paths, Ex c:parentFolderfolderanotherFolder instead of c:\parentFolder\folder\anotherFolder
-      if (win) {
-        nodeLibFile = nodeLibFile.replace(/\\/g, '\\\\')
-      }
-      argv.push('-Dnode_lib_file=' + nodeLibFile)
-      argv.push('-Dmodule_root_dir=' + process.cwd())
-      argv.push('-Dnode_engine=' +
-        (gyp.opts.node_engine || process.jsEngine || 'v8'))
-      argv.push('--depth=.')
-      argv.push('--no-parallel')
+    let nodeLibFile = path.join(nodeDir,
+      !gyp.opts.nodedir ? '<(target_arch)' : '$(Configuration)',
+      release.name + '.lib')
 
-      // tell gyp to write the Makefile/Solution files into output_dir
-      argv.push('--generator-output', outputDir)
+    argv.push('-I', addonGypi)
+    argv.push('-I', commonGypi)
+    argv.push('-Dlibrary=shared_library')
+    argv.push('-Dvisibility=default')
+    argv.push('-Dnode_root_dir=' + nodeDir)
+    if (process.platform === 'aix' || process.platform === 'os390' || process.platform === 'os400') {
+      argv.push('-Dnode_exp_file=' + nodeExpFile)
+      if (process.platform === 'os390' && zoslibIncDir) {
+        argv.push('-Dzoslib_include_dir=' + zoslibIncDir)
+      }
+    }
+    argv.push('-Dnode_gyp_dir=' + nodeGypDir)
 
-      // tell make to write its output into the same dir
-      argv.push('-Goutput_dir=.')
+    // Do this to keep Cygwin environments happy, else the unescaped '\' gets eaten up,
+    // resulting in bad paths, Ex c:parentFolderfolderanotherFolder instead of c:\parentFolder\folder\anotherFolder
+    if (win) {
+      nodeLibFile = nodeLibFile.replace(/\\/g, '\\\\')
+    }
+    argv.push('-Dnode_lib_file=' + nodeLibFile)
+    argv.push('-Dmodule_root_dir=' + process.cwd())
+    argv.push('-Dnode_engine=' +
+        (gyp.opts.node_engine || process.jsEngine || 'v8'))
+    argv.push('--depth=.')
+    argv.push('--no-parallel')
 
-      // enforce use of the "binding.gyp" file
-      argv.unshift('binding.gyp')
+    // tell gyp to write the Makefile/Solution files into output_dir
+    argv.push('--generator-output', outputDir)
 
-      // execute `gyp` from the current target nodedir
-      argv.unshift(gypScript)
+    // tell make to write its output into the same dir
+    argv.push('-Goutput_dir=.')
 
-      // make sure python uses files that came with this particular node package
-      var pypath = [path.join(__dirname, '..', 'gyp', 'pylib')]
-      if (process.env.PYTHONPATH) {
-        pypath.push(process.env.PYTHONPATH)
-      }
-      process.env.PYTHONPATH = pypath.join(win ? ';' : ':')
+    // enforce use of the "binding.gyp" file
+    argv.unshift('binding.gyp')
 
-      var cp = gyp.spawn(python, argv)
-      cp.on('exit', onCpExit)
-    })
-  }
+    // execute `gyp` from the current target nodedir
+    argv.unshift(gypScript)
 
-  function onCpExit (code) {
-    if (code !== 0) {
-      callback(new Error('`gyp` failed with exit code: ' + code))
-    } else {
-      // we're done
-      callback()
+    // make sure python uses files that came with this particular node package
+    const pypath = [path.join(__dirname, '..', 'gyp', 'pylib')]
+    if (process.env.PYTHONPATH) {
+      pypath.push(process.env.PYTHONPATH)
     }
-  }
-}
+    process.env.PYTHONPATH = pypath.join(win ? ';' : ':')
 
-/**
- * Returns the first file or directory from an array of candidates that is
- * readable by the current user, or undefined if none of the candidates are
- * readable.
- */
-function findAccessibleSync (logprefix, dir, candidates) {
-  for (var next = 0; next < candidates.length; next++) {
-    var candidate = path.resolve(dir, candidates[next])
-    try {
-      var fd = fs.openSync(candidate, 'r')
-    } catch (e) {
-      // this candidate was not found or not readable, do nothing
-      log.silly(logprefix, 'Could not open %s: %s', candidate, e.message)
-      continue
-    }
-    fs.closeSync(fd)
-    log.silly(logprefix, 'Found readable %s', candidate)
-    return candidate
+    await new Promise((resolve, reject) => {
+      const cp = gyp.spawn(python, argv)
+      cp.on('exit', (code) => {
+        if (code !== 0) {
+          reject(new Error('`gyp` failed with exit code: ' + code))
+        } else {
+          // we're done
+          resolve()
+        }
+      })
+    })
   }
-
-  return undefined
 }
 
 module.exports = configure
-module.exports.test = {
-  findAccessibleSync: findAccessibleSync
-}
 module.exports.usage = 'Generates ' + (win ? 'MSVC project files' : 'a Makefile') + ' for the current module'

package/dist/node_modules/node-gyp/lib/create-config-gypi.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const fs = require('graceful-fs')
-const log = require('npmlog')
+const fs = require('graceful-fs').promises
+const log = require('./log')
 const path = require('path')
 
 function parseConfigGypi (config) {
@@ -24,7 +24,7 @@ async function getBaseConfigGypi ({ gyp, nodeDir }) {
   if (shouldReadConfigGypi && nodeDir) {
     try {
       const baseConfigGypiPath = path.resolve(nodeDir, 'include/node/config.gypi')
-      const baseConfigGypi = await fs.promises.readFile(baseConfigGypiPath)
+      const baseConfigGypi = await fs.readFile(baseConfigGypiPath)
       return parseConfigGypi(baseConfigGypi.toString())
     } catch (err) {
       log.warn('read config.gypi', err.message)
@@ -35,7 +35,7 @@ async function getBaseConfigGypi ({ gyp, nodeDir }) {
   return JSON.parse(JSON.stringify(process.config))
 }
 
-async function getCurrentConfigGypi ({ gyp, nodeDir, vsInfo }) {
+async function getCurrentConfigGypi ({ gyp, nodeDir, vsInfo, python }) {
   const config = await getBaseConfigGypi({ gyp, nodeDir })
   if (!config.target_defaults) {
     config.target_defaults = {}
@@ -75,6 +75,9 @@ async function getCurrentConfigGypi ({ gyp, nodeDir, vsInfo }) {
   // set the node development directory
   variables.nodedir = nodeDir
 
+  // set the configured Python path
+  variables.python = python
+
   // disable -T "thin" static archives by default
   variables.standalone_static_library = gyp.opts.thin ? 0 : 1
 
@@ -112,13 +115,13 @@ async function getCurrentConfigGypi ({ gyp, nodeDir, vsInfo }) {
   return config
 }
 
-async function createConfigGypi ({ gyp, buildDir, nodeDir, vsInfo }) {
+async function createConfigGypi ({ gyp, buildDir, nodeDir, vsInfo, python }) {
   const configFilename = 'config.gypi'
   const configPath = path.resolve(buildDir, configFilename)
 
   log.verbose('build/' + configFilename, 'creating config file')
 
-  const config = await getCurrentConfigGypi({ gyp, nodeDir, vsInfo })
+  const config = await getCurrentConfigGypi({ gyp, nodeDir, vsInfo, python })
 
   // ensures that any boolean values in config.gypi get stringified
   function boolsToString (k, v) {
@@ -135,13 +138,13 @@ async function createConfigGypi ({ gyp, buildDir, nodeDir, vsInfo }) {
 
   const json = JSON.stringify(config, boolsToString, 2)
   log.verbose('build/' + configFilename, 'writing out config file: %s', configPath)
-  await fs.promises.writeFile(configPath, [prefix, json, ''].join('\n'))
+  await fs.writeFile(configPath, [prefix, json, ''].join('\n'))
 
   return configPath
 }
 
-module.exports = createConfigGypi
-module.exports.test = {
-  parseConfigGypi: parseConfigGypi,
-  getCurrentConfigGypi: getCurrentConfigGypi
+module.exports = {
+  createConfigGypi,
+  parseConfigGypi,
+  getCurrentConfigGypi
 }

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

@@ -0,0 +1,39 @@
+const fetch = require('make-fetch-happen')
+const { promises: fs } = require('graceful-fs')
+const log = require('./log')
+
+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.readFile(filename, 'utf8')
+  const re = /(-----BEGIN CERTIFICATE-----[\S\s]*?-----END CERTIFICATE-----)/g
+  return ca.match(re)
+}
+
+module.exports = {
+  download,
+  readCAFile
+}

package/dist/node_modules/node-gyp/lib/find-node-directory.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const path = require('path')
-const log = require('npmlog')
+const log = require('./log')
 
 function findNodeDirectory (scriptLocation, processObj) {
   // set dirname and process if not passed in
@@ -14,10 +14,10 @@ function findNodeDirectory (scriptLocation, processObj) {
   }
 
   // Have a look to see what is above us, to try and work out where we are
-  var npmParentDirectory = path.join(scriptLocation, '../../../..')
+  const npmParentDirectory = path.join(scriptLocation, '../../../..')
   log.verbose('node-gyp root', 'npm_parent_directory is ' +
               path.basename(npmParentDirectory))
-  var nodeRootDir = ''
+  let nodeRootDir = ''
 
   log.verbose('node-gyp root', 'Finding node root directory')
   if (path.basename(npmParentDirectory) === 'deps') {
@@ -41,8 +41,8 @@ function findNodeDirectory (scriptLocation, processObj) {
   } else {
     // We don't know where we are, try working it out from the location
     // of the node binary
-    var nodeDir = path.dirname(processObj.execPath)
-    var directoryUp = path.basename(nodeDir)
+    const nodeDir = path.dirname(processObj.execPath)
+    const directoryUp = path.basename(nodeDir)
     if (directoryUp === 'bin') {
       nodeRootDir = path.join(nodeDir, '..')
     } else if (directoryUp === 'Release' || directoryUp === 'Debug') {