pxnpm 3.0.7 → 4.0.0

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

@@ -0,0 +1,147 @@
+'use strict'
+
+const fs = require('graceful-fs')
+const log = require('npmlog')
+const path = require('path')
+
+function parseConfigGypi (config) {
+  // translated from tools/js2c.py of Node.js
+  // 1. string comments
+  config = config.replace(/#.*/g, '')
+  // 2. join multiline strings
+  config = config.replace(/'$\s+'/mg, '')
+  // 3. normalize string literals from ' into "
+  config = config.replace(/'/g, '"')
+  return JSON.parse(config)
+}
+
+async function getBaseConfigGypi ({ gyp, nodeDir }) {
+  // try reading $nodeDir/include/node/config.gypi first when:
+  // 1. --dist-url or --nodedir is specified
+  // 2. and --force-process-config is not specified
+  const useCustomHeaders = gyp.opts.nodedir || gyp.opts.disturl || gyp.opts['dist-url']
+  const shouldReadConfigGypi = useCustomHeaders && !gyp.opts['force-process-config']
+  if (shouldReadConfigGypi && nodeDir) {
+    try {
+      const baseConfigGypiPath = path.resolve(nodeDir, 'include/node/config.gypi')
+      const baseConfigGypi = await fs.promises.readFile(baseConfigGypiPath)
+      return parseConfigGypi(baseConfigGypi.toString())
+    } catch (err) {
+      log.warn('read config.gypi', err.message)
+    }
+  }
+
+  // fallback to process.config if it is invalid
+  return JSON.parse(JSON.stringify(process.config))
+}
+
+async function getCurrentConfigGypi ({ gyp, nodeDir, vsInfo }) {
+  const config = await getBaseConfigGypi({ gyp, nodeDir })
+  if (!config.target_defaults) {
+    config.target_defaults = {}
+  }
+  if (!config.variables) {
+    config.variables = {}
+  }
+
+  const defaults = config.target_defaults
+  const variables = config.variables
+
+  // don't inherit the "defaults" from the base config.gypi.
+  // doing so could cause problems in cases where the `node` executable was
+  // compiled on a different machine (with different lib/include paths) than
+  // the machine where the addon is being built to
+  defaults.cflags = []
+  defaults.defines = []
+  defaults.include_dirs = []
+  defaults.libraries = []
+
+  // set the default_configuration prop
+  if ('debug' in gyp.opts) {
+    defaults.default_configuration = gyp.opts.debug ? 'Debug' : 'Release'
+  }
+
+  if (!defaults.default_configuration) {
+    defaults.default_configuration = 'Release'
+  }
+
+  // set the target_arch variable
+  variables.target_arch = gyp.opts.arch || process.arch || 'ia32'
+  if (variables.target_arch === 'arm64') {
+    defaults.msvs_configuration_platform = 'ARM64'
+    defaults.xcode_configuration_platform = 'arm64'
+  }
+
+  // set the node development directory
+  variables.nodedir = nodeDir
+
+  // disable -T "thin" static archives by default
+  variables.standalone_static_library = gyp.opts.thin ? 0 : 1
+
+  if (process.platform === 'win32') {
+    defaults.msbuild_toolset = vsInfo.toolset
+    if (vsInfo.sdk) {
+      defaults.msvs_windows_target_platform_version = vsInfo.sdk
+    }
+    if (variables.target_arch === 'arm64') {
+      if (vsInfo.versionMajor > 15 ||
+          (vsInfo.versionMajor === 15 && vsInfo.versionMajor >= 9)) {
+        defaults.msvs_enable_marmasm = 1
+      } else {
+        log.warn('Compiling ARM64 assembly is only available in\n' +
+          'Visual Studio 2017 version 15.9 and above')
+      }
+    }
+    variables.msbuild_path = vsInfo.msBuild
+  }
+
+  // loop through the rest of the opts and add the unknown ones as variables.
+  // this allows for module-specific configure flags like:
+  //
+  //   $ node-gyp configure --shared-libxml2
+  Object.keys(gyp.opts).forEach(function (opt) {
+    if (opt === 'argv') {
+      return
+    }
+    if (opt in gyp.configDefs) {
+      return
+    }
+    variables[opt.replace(/-/g, '_')] = gyp.opts[opt]
+  })
+
+  return config
+}
+
+async function createConfigGypi ({ gyp, buildDir, nodeDir, vsInfo }) {
+  const configFilename = 'config.gypi'
+  const configPath = path.resolve(buildDir, configFilename)
+
+  log.verbose('build/' + configFilename, 'creating config file')
+
+  const config = await getCurrentConfigGypi({ gyp, nodeDir, vsInfo })
+
+  // ensures that any boolean values in config.gypi get stringified
+  function boolsToString (k, v) {
+    if (typeof v === 'boolean') {
+      return String(v)
+    }
+    return v
+  }
+
+  log.silly('build/' + configFilename, config)
+
+  // now write out the config.gypi file to the build/ dir
+  const prefix = '# Do not edit. File was generated by node-gyp\'s "configure" step'
+
+  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'))
+
+  return configPath
+}
+
+module.exports = createConfigGypi
+module.exports.test = {
+  parseConfigGypi: parseConfigGypi,
+  getCurrentConfigGypi: getCurrentConfigGypi
+}

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const path = require('path')
+const log = require('npmlog')
+
+function findNodeDirectory (scriptLocation, processObj) {
+  // set dirname and process if not passed in
+  // this facilitates regression tests
+  if (scriptLocation === undefined) {
+    scriptLocation = __dirname
+  }
+  if (processObj === undefined) {
+    processObj = process
+  }
+
+  // Have a look to see what is above us, to try and work out where we are
+  var npmParentDirectory = path.join(scriptLocation, '../../../..')
+  log.verbose('node-gyp root', 'npm_parent_directory is ' +
+              path.basename(npmParentDirectory))
+  var nodeRootDir = ''
+
+  log.verbose('node-gyp root', 'Finding node root directory')
+  if (path.basename(npmParentDirectory) === 'deps') {
+    // We are in a build directory where this script lives in
+    // deps/npm/node_modules/node-gyp/lib
+    nodeRootDir = path.join(npmParentDirectory, '..')
+    log.verbose('node-gyp root', 'in build directory, root = ' +
+                nodeRootDir)
+  } else if (path.basename(npmParentDirectory) === 'node_modules') {
+    // We are in a node install directory where this script lives in
+    // lib/node_modules/npm/node_modules/node-gyp/lib or
+    // node_modules/npm/node_modules/node-gyp/lib depending on the
+    // platform
+    if (processObj.platform === 'win32') {
+      nodeRootDir = path.join(npmParentDirectory, '..')
+    } else {
+      nodeRootDir = path.join(npmParentDirectory, '../..')
+    }
+    log.verbose('node-gyp root', 'in install directory, root = ' +
+                nodeRootDir)
+  } 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)
+    if (directoryUp === 'bin') {
+      nodeRootDir = path.join(nodeDir, '..')
+    } else if (directoryUp === 'Release' || directoryUp === 'Debug') {
+      // If we are a recently built node, and the directory structure
+      // is that of a repository. If we are on Windows then we only need
+      // to go one level up, everything else, two
+      if (processObj.platform === 'win32') {
+        nodeRootDir = path.join(nodeDir, '..')
+      } else {
+        nodeRootDir = path.join(nodeDir, '../..')
+      }
+    }
+    // Else return the default blank, "".
+  }
+  return nodeRootDir
+}
+
+module.exports = findNodeDirectory

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

@@ -0,0 +1,344 @@
+'use strict'
+
+const log = require('npmlog')
+const semver = require('semver')
+const cp = require('child_process')
+const extend = require('util')._extend // eslint-disable-line
+const win = process.platform === 'win32'
+const logWithPrefix = require('./util').logWithPrefix
+
+const systemDrive = process.env.SystemDrive || 'C:'
+const username = process.env.USERNAME || process.env.USER || getOsUserInfo()
+const localAppData = process.env.LOCALAPPDATA || `${systemDrive}\\${username}\\AppData\\Local`
+const foundLocalAppData = process.env.LOCALAPPDATA || username
+const programFiles = process.env.ProgramW6432 || process.env.ProgramFiles || `${systemDrive}\\Program Files`
+const programFilesX86 = process.env['ProgramFiles(x86)'] || `${programFiles} (x86)`
+
+const winDefaultLocationsArray = []
+for (const majorMinor of ['39', '38', '37', '36']) {
+  if (foundLocalAppData) {
+    winDefaultLocationsArray.push(
+      `${localAppData}\\Programs\\Python\\Python${majorMinor}\\python.exe`,
+      `${programFiles}\\Python${majorMinor}\\python.exe`,
+      `${localAppData}\\Programs\\Python\\Python${majorMinor}-32\\python.exe`,
+      `${programFiles}\\Python${majorMinor}-32\\python.exe`,
+      `${programFilesX86}\\Python${majorMinor}-32\\python.exe`
+    )
+  } else {
+    winDefaultLocationsArray.push(
+      `${programFiles}\\Python${majorMinor}\\python.exe`,
+      `${programFiles}\\Python${majorMinor}-32\\python.exe`,
+      `${programFilesX86}\\Python${majorMinor}-32\\python.exe`
+    )
+  }
+}
+
+function getOsUserInfo () {
+  try {
+    return require('os').userInfo().username
+  } catch (e) {}
+}
+
+function PythonFinder (configPython, callback) {
+  this.callback = callback
+  this.configPython = configPython
+  this.errorLog = []
+}
+
+PythonFinder.prototype = {
+  log: logWithPrefix(log, 'find Python'),
+  argsExecutable: ['-c', 'import sys; print(sys.executable);'],
+  argsVersion: ['-c', 'import sys; print("%s.%s.%s" % sys.version_info[:3]);'],
+  semverRange: '>=3.6.0',
+
+  // These can be overridden for testing:
+  execFile: cp.execFile,
+  env: process.env,
+  win: win,
+  pyLauncher: 'py.exe',
+  winDefaultLocations: winDefaultLocationsArray,
+
+  // Logs a message at verbose level, but also saves it to be displayed later
+  // at error level if an error occurs. This should help diagnose the problem.
+  addLog: function addLog (message) {
+    this.log.verbose(message)
+    this.errorLog.push(message)
+  },
+
+  // Find Python by trying a sequence of possibilities.
+  // Ignore errors, keep trying until Python is found.
+  findPython: function findPython () {
+    const SKIP = 0; const FAIL = 1
+    var toCheck = getChecks.apply(this)
+
+    function getChecks () {
+      if (this.env.NODE_GYP_FORCE_PYTHON) {
+        return [{
+          before: () => {
+            this.addLog(
+              'checking Python explicitly set from NODE_GYP_FORCE_PYTHON')
+            this.addLog('- process.env.NODE_GYP_FORCE_PYTHON is ' +
+              `"${this.env.NODE_GYP_FORCE_PYTHON}"`)
+          },
+          check: this.checkCommand,
+          arg: this.env.NODE_GYP_FORCE_PYTHON
+        }]
+      }
+
+      var checks = [
+        {
+          before: () => {
+            if (!this.configPython) {
+              this.addLog(
+                'Python is not set from command line or npm configuration')
+              return SKIP
+            }
+            this.addLog('checking Python explicitly set from command line or ' +
+              'npm configuration')
+            this.addLog('- "--python=" or "npm config get python" is ' +
+              `"${this.configPython}"`)
+          },
+          check: this.checkCommand,
+          arg: this.configPython
+        },
+        {
+          before: () => {
+            if (!this.env.PYTHON) {
+              this.addLog('Python is not set from environment variable ' +
+                'PYTHON')
+              return SKIP
+            }
+            this.addLog('checking Python explicitly set from environment ' +
+              'variable PYTHON')
+            this.addLog(`- process.env.PYTHON is "${this.env.PYTHON}"`)
+          },
+          check: this.checkCommand,
+          arg: this.env.PYTHON
+        },
+        {
+          before: () => { this.addLog('checking if "python3" can be used') },
+          check: this.checkCommand,
+          arg: 'python3'
+        },
+        {
+          before: () => { this.addLog('checking if "python" can be used') },
+          check: this.checkCommand,
+          arg: 'python'
+        }
+      ]
+
+      if (this.win) {
+        for (var i = 0; i < this.winDefaultLocations.length; ++i) {
+          const location = this.winDefaultLocations[i]
+          checks.push({
+            before: () => {
+              this.addLog('checking if Python is ' +
+                `${location}`)
+            },
+            check: this.checkExecPath,
+            arg: location
+          })
+        }
+        checks.push({
+          before: () => {
+            this.addLog(
+              'checking if the py launcher can be used to find Python 3')
+          },
+          check: this.checkPyLauncher
+        })
+      }
+
+      return checks
+    }
+
+    function runChecks (err) {
+      this.log.silly('runChecks: err = %j', (err && err.stack) || err)
+
+      const check = toCheck.shift()
+      if (!check) {
+        return this.fail()
+      }
+
+      const before = check.before.apply(this)
+      if (before === SKIP) {
+        return runChecks.apply(this)
+      }
+      if (before === FAIL) {
+        return this.fail()
+      }
+
+      const args = [runChecks.bind(this)]
+      if (check.arg) {
+        args.unshift(check.arg)
+      }
+      check.check.apply(this, args)
+    }
+
+    runChecks.apply(this)
+  },
+
+  // Check if command is a valid Python to use.
+  // Will exit the Python finder on success.
+  // If on Windows, run in a CMD shell to support BAT/CMD launchers.
+  checkCommand: function checkCommand (command, errorCallback) {
+    var exec = command
+    var args = this.argsExecutable
+    var shell = false
+    if (this.win) {
+      // Arguments have to be manually quoted
+      exec = `"${exec}"`
+      args = args.map(a => `"${a}"`)
+      shell = true
+    }
+
+    this.log.verbose(`- executing "${command}" to get executable path`)
+    this.run(exec, args, shell, function (err, execPath) {
+      // Possible outcomes:
+      // - Error: not in PATH, not executable or execution fails
+      // - Gibberish: the next command to check version will fail
+      // - Absolute path to executable
+      if (err) {
+        this.addLog(`- "${command}" is not in PATH or produced an error`)
+        return errorCallback(err)
+      }
+      this.addLog(`- executable path is "${execPath}"`)
+      this.checkExecPath(execPath, errorCallback)
+    }.bind(this))
+  },
+
+  // Check if the py launcher can find a valid Python to use.
+  // Will exit the Python finder on success.
+  // Distributions of Python on Windows by default install with the "py.exe"
+  // Python launcher which is more likely to exist than the Python executable
+  // being in the $PATH.
+  // Because the Python launcher supports Python 2 and Python 3, we should
+  // explicitly request a Python 3 version. This is done by supplying "-3" as
+  // the first command line argument. Since "py.exe -3" would be an invalid
+  // executable for "execFile", we have to use the launcher to figure out
+  // where the actual "python.exe" executable is located.
+  checkPyLauncher: function checkPyLauncher (errorCallback) {
+    this.log.verbose(
+      `- executing "${this.pyLauncher}" to get Python 3 executable path`)
+    this.run(this.pyLauncher, ['-3', ...this.argsExecutable], false,
+      function (err, execPath) {
+      // Possible outcomes: same as checkCommand
+        if (err) {
+          this.addLog(
+            `- "${this.pyLauncher}" is not in PATH or produced an error`)
+          return errorCallback(err)
+        }
+        this.addLog(`- executable path is "${execPath}"`)
+        this.checkExecPath(execPath, errorCallback)
+      }.bind(this))
+  },
+
+  // Check if a Python executable is the correct version to use.
+  // Will exit the Python finder on success.
+  checkExecPath: function checkExecPath (execPath, errorCallback) {
+    this.log.verbose(`- executing "${execPath}" to get version`)
+    this.run(execPath, this.argsVersion, false, function (err, version) {
+      // Possible outcomes:
+      // - Error: executable can not be run (likely meaning the command wasn't
+      //   a Python executable and the previous command produced gibberish)
+      // - Gibberish: somehow the last command produced an executable path,
+      //   this will fail when verifying the version
+      // - Version of the Python executable
+      if (err) {
+        this.addLog(`- "${execPath}" could not be run`)
+        return errorCallback(err)
+      }
+      this.addLog(`- version is "${version}"`)
+
+      const range = new semver.Range(this.semverRange)
+      var valid = false
+      try {
+        valid = range.test(version)
+      } catch (err) {
+        this.log.silly('range.test() threw:\n%s', err.stack)
+        this.addLog(`- "${execPath}" does not have a valid version`)
+        this.addLog('- is it a Python executable?')
+        return errorCallback(err)
+      }
+
+      if (!valid) {
+        this.addLog(`- version is ${version} - should be ${this.semverRange}`)
+        this.addLog('- THIS VERSION OF PYTHON IS NOT SUPPORTED')
+        return errorCallback(new Error(
+          `Found unsupported Python version ${version}`))
+      }
+      this.succeed(execPath, version)
+    }.bind(this))
+  },
+
+  // Run an executable or shell command, trimming the output.
+  run: function run (exec, args, shell, callback) {
+    var env = extend({}, this.env)
+    env.TERM = 'dumb'
+    const opts = { env: env, shell: shell }
+
+    this.log.silly('execFile: exec = %j', exec)
+    this.log.silly('execFile: args = %j', args)
+    this.log.silly('execFile: opts = %j', opts)
+    try {
+      this.execFile(exec, args, opts, execFileCallback.bind(this))
+    } catch (err) {
+      this.log.silly('execFile: threw:\n%s', err.stack)
+      return callback(err)
+    }
+
+    function execFileCallback (err, stdout, stderr) {
+      this.log.silly('execFile result: err = %j', (err && err.stack) || err)
+      this.log.silly('execFile result: stdout = %j', stdout)
+      this.log.silly('execFile result: stderr = %j', stderr)
+      if (err) {
+        return callback(err)
+      }
+      const execPath = stdout.trim()
+      callback(null, execPath)
+    }
+  },
+
+  succeed: function succeed (execPath, version) {
+    this.log.info(`using Python version ${version} found at "${execPath}"`)
+    process.nextTick(this.callback.bind(null, null, execPath))
+  },
+
+  fail: function fail () {
+    const errorLog = this.errorLog.join('\n')
+
+    const pathExample = this.win ? 'C:\\Path\\To\\python.exe'
+      : '/path/to/pythonexecutable'
+    // For Windows 80 col console, use up to the column before the one marked
+    // with X (total 79 chars including logger prefix, 58 chars usable here):
+    //                                                           X
+    const info = [
+      '**********************************************************',
+      'You need to install the latest version of Python.',
+      'Node-gyp should be able to find and use Python. If not,',
+      'you can try one of the following options:',
+      `- Use the switch --python="${pathExample}"`,
+      '  (accepted by both node-gyp and npm)',
+      '- Set the environment variable PYTHON',
+      '- Set the npm configuration variable python:',
+      `  npm config set python "${pathExample}"`,
+      'For more information consult the documentation at:',
+      'https://github.com/nodejs/node-gyp#installation',
+      '**********************************************************'
+    ].join('\n')
+
+    this.log.error(`\n${errorLog}\n\n${info}\n`)
+    process.nextTick(this.callback.bind(null, new Error(
+      'Could not find any Python installation to use')))
+  }
+}
+
+function findPython (configPython, callback) {
+  var finder = new PythonFinder(configPython, callback)
+  finder.findPython()
+}
+
+module.exports = findPython
+module.exports.test = {
+  PythonFinder: PythonFinder,
+  findPython: findPython
+}