pnpm 11.23.0 → 11.25.0

package/artifacts/exe/dist/node_modules/node-gyp/lib/build.js

@@ -1,230 +0,0 @@
-'use strict'
-
-const gracefulFs = require('graceful-fs')
-const fs = gracefulFs.promises
-const path = require('path')
-const { glob } = require('tinyglobby')
-const log = require('./log')
-const which = require('which')
-const win = process.platform === 'win32'
-
-async function build (gyp, argv) {
-  let platformMake = 'make'
-  if (process.platform === 'aix') {
-    platformMake = 'gmake'
-  } else if (process.platform === 'os400') {
-    platformMake = 'gmake'
-  } else if (process.platform.indexOf('bsd') !== -1) {
-    platformMake = 'gmake'
-  } else if (win && argv.length > 0) {
-    argv = argv.map(function (target) {
-      return '/t:' + target
-    })
-  }
-
-  const makeCommand = gyp.opts.make || process.env.MAKE || platformMake
-  let command = win ? 'msbuild' : makeCommand
-  const jobs = gyp.opts.jobs || process.env.JOBS
-  let buildType
-  let config
-  let arch
-  let nodeDir
-  let guessedSolution
-  let python
-  let buildBinsDir
-
-  await loadConfigGypi()
-
-  /**
-   * Load the "config.gypi" file that was generated during "configure".
-   */
-
-  async function loadConfigGypi () {
-    let data
-    try {
-      const configPath = path.resolve('build', 'config.gypi')
-      data = await fs.readFile(configPath, 'utf8')
-    } catch (err) {
-      if (err.code === 'ENOENT') {
-        throw new Error('You must run `node-gyp configure` first!')
-      } else {
-        throw err
-      }
-    }
-
-    config = JSON.parse(data.replace(/#.+\n/, ''))
-
-    // get the 'arch', 'buildType', and 'nodeDir' vars from the config
-    buildType = config.target_defaults.default_configuration
-    arch = config.variables.target_arch
-    nodeDir = config.variables.nodedir
-    python = config.variables.python
-
-    if ('debug' in gyp.opts) {
-      buildType = gyp.opts.debug ? 'Debug' : 'Release'
-    }
-    if (!buildType) {
-      buildType = 'Release'
-    }
-
-    log.verbose('build type', buildType)
-    log.verbose('architecture', arch)
-    log.verbose('node dev dir', nodeDir)
-    log.verbose('python', python)
-
-    if (win) {
-      await findSolutionFile()
-    } else {
-      await doWhich()
-    }
-  }
-
-  /**
-   * On Windows, find the first build/*.sln file.
-   */
-
-  async function findSolutionFile () {
-    const files = await glob('build/*.sln', { expandDirectories: false })
-    if (files.length === 0) {
-      if (gracefulFs.existsSync('build/Makefile') ||
-          (await glob('build/*.mk', { expandDirectories: false })).length !== 0) {
-        command = makeCommand
-        await doWhich(false)
-        return
-      } else {
-        throw new Error('Could not find *.sln file or Makefile. Did you run "configure"?')
-      }
-    }
-    guessedSolution = files[0]
-    log.verbose('found first Solution file', guessedSolution)
-    await doWhich(true)
-  }
-
-  /**
-   * Uses node-which to locate the msbuild / make executable.
-   */
-
-  async function doWhich (msvs) {
-    // On Windows use msbuild provided by node-gyp configure
-    if (msvs) {
-      if (!config.variables.msbuild_path) {
-        throw new Error('MSBuild is not set, please run `node-gyp configure`.')
-      }
-      command = config.variables.msbuild_path
-      log.verbose('using MSBuild:', command)
-      await doBuild(msvs)
-      return
-    }
-
-    // First make sure we have the build command in the PATH
-    const execPath = await which(command)
-    log.verbose('`which` succeeded for `' + command + '`', execPath)
-    await doBuild(msvs)
-  }
-
-  /**
-   * Actually spawn the process and compile the module.
-   */
-
-  async function doBuild (msvs) {
-    // Enable Verbose build
-    const verbose = log.logger.isVisible('verbose')
-    let j
-
-    if (!msvs && verbose) {
-      argv.push('V=1')
-    }
-
-    if (msvs && !verbose) {
-      argv.push('/clp:Verbosity=minimal')
-    }
-
-    if (msvs) {
-      // Turn off the Microsoft logo on Windows
-      argv.push('/nologo')
-      // No lingering msbuild processes and open file handles
-      argv.push('/nodeReuse:false')
-    }
-
-    // Specify the build type, Release by default
-    if (msvs) {
-      // Convert .gypi config target_arch to MSBuild /Platform
-      // Since there are many ways to state '32-bit Intel', default to it.
-      // N.B. msbuild's Condition string equality tests are case-insensitive.
-      const archLower = arch.toLowerCase()
-      const p = archLower === 'x64'
-        ? 'x64'
-        : (archLower === 'arm'
-            ? 'ARM'
-            : (archLower === 'arm64' ? 'ARM64' : 'Win32'))
-      argv.push('/p:Configuration=' + buildType + ';Platform=' + p)
-      if (jobs) {
-        j = parseInt(jobs, 10)
-        if (!isNaN(j) && j > 0) {
-          argv.push('/m:' + j)
-        } else if (jobs.toUpperCase() === 'MAX') {
-          argv.push('/m:' + require('os').availableParallelism())
-        }
-      }
-    } else {
-      argv.push('BUILDTYPE=' + buildType)
-      // Invoke the Makefile in the 'build' dir.
-      argv.push('-C')
-      argv.push('build')
-      if (jobs) {
-        j = parseInt(jobs, 10)
-        if (!isNaN(j) && j > 0) {
-          argv.push('--jobs')
-          argv.push(j)
-        } else if (jobs.toUpperCase() === 'MAX') {
-          argv.push('--jobs')
-          argv.push(require('os').availableParallelism())
-        }
-      }
-    }
-
-    if (msvs) {
-      // did the user specify their own .sln file?
-      const hasSln = argv.some(function (arg) {
-        return path.extname(arg) === '.sln'
-      })
-      if (!hasSln) {
-        argv.unshift(gyp.opts.solution || guessedSolution)
-      }
-    }
-
-    if (!win) {
-      // Add build-time dependency symlinks (such as Python) to PATH
-      buildBinsDir = path.resolve('build', 'node_gyp_bins')
-      process.env.PATH = `${buildBinsDir}:${process.env.PATH}`
-      await fs.mkdir(buildBinsDir, { recursive: true })
-      const symlinkDestination = path.join(buildBinsDir, 'python3')
-      try {
-        await fs.unlink(symlinkDestination)
-      } catch (err) {
-        if (err.code !== 'ENOENT') throw err
-      }
-      await fs.symlink(python, symlinkDestination)
-      log.verbose('bin symlinks', `created symlink to "${python}" in "${buildBinsDir}" and added to PATH`)
-    }
-
-    const proc = gyp.spawn(command, argv)
-    await new Promise((resolve, reject) => proc.on('exit', async (code, signal) => {
-      if (buildBinsDir) {
-        // Clean up the build-time dependency symlinks:
-        await fs.rm(buildBinsDir, { recursive: true, maxRetries: 3 })
-      }
-
-      if (code !== 0) {
-        return reject(new Error('`' + command + '` failed with exit code: ' + code))
-      }
-      if (signal) {
-        return reject(new Error('`' + command + '` got signal: ' + signal))
-      }
-      resolve()
-    }))
-  }
-}
-
-module.exports = build
-module.exports.usage = 'Invokes `' + (win ? 'msbuild' : 'make') + '` and builds the module'

package/artifacts/exe/dist/node_modules/node-gyp/lib/clean.js

@@ -1,15 +0,0 @@
-'use strict'
-
-const fs = require('graceful-fs').promises
-const log = require('./log')
-
-async function clean (gyp, argv) {
-  // Remove the 'build' dir
-  const buildDir = 'build'
-
-  log.verbose('clean', 'removing "%s" directory', buildDir)
-  await fs.rm(buildDir, { recursive: true, force: true, maxRetries: 3 })
-}
-
-module.exports = clean
-module.exports.usage = 'Removes any generated build files and the "out" dir'

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

@@ -1,328 +0,0 @@
-'use strict'
-
-const { promises: fs, readFileSync } = require('graceful-fs')
-const path = require('path')
-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 { 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)
-    } else {
-      // if no --nodedir specified, ensure node dependencies are installed
-      if ('v' + release.version !== process.version) {
-        // if --target was given, then determine a target version to compile for
-        log.verbose('get node dir', 'compiling against --target node version: %s', release.version)
-      } else {
-        // if no --target was specified then use the current host node version
-        log.verbose('get node dir', 'no --target version specified, falling back to host node version: %s', release.version)
-      }
-
-      if (!release.semver) {
-        // could not parse the version string with semver
-        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
-
-      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()
-  }
-
-  async function createBuildDir () {
-    log.verbose('build dir', 'attempting to create "build" dir: %s', buildDir)
-
-    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
-        }
-      }
-      let vsInfo = {}
-      if (!usingMakeGenerator) {
-        vsInfo = await findVisualStudio(release.semver, gyp.opts['msvs-version'])
-      }
-      return createConfigFile(vsInfo)
-    }
-    return createConfigFile(null)
-  }
-
-  async function createConfigFile (vsInfo) {
-    if (win) {
-      process.env.GYP_MSVS_VERSION = Math.min(vsInfo.versionYear, 2015)
-      process.env.GYP_MSVS_OVERRIDE_PATH = vsInfo.path
-    }
-    const configPath = await createConfigGypi({ gyp, buildDir, nodeDir, vsInfo, python })
-    configs.push(configPath)
-    return findConfigs()
-  }
-
-  async function findConfigs () {
-    const name = configNames.shift()
-    if (!name) {
-      return runGyp()
-    }
-
-    const fullPath = path.resolve(name)
-    log.verbose(name, 'checking for gypi file: %s', fullPath)
-    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
-      }
-    }
-
-    return findConfigs()
-  }
-
-  async function runGyp () {
-    if (!~argv.indexOf('-f') && !~argv.indexOf('--format')) {
-      if (win) {
-        log.verbose('gyp', 'gyp format was not specified; forcing "msvs"')
-        // force the 'make' target for non-Windows
-        argv.push('-f', 'msvs')
-      } else {
-        log.verbose('gyp', 'gyp format was not specified; forcing "make"')
-        // force the 'make' target for non-Windows
-        argv.push('-f', 'make')
-      }
-    }
-
-    // include all the ".gypi" files that were found
-    configs.forEach(function (config) {
-      argv.push('-I', config)
-    })
-
-    // For AIX and z/OS we need to set up the path to the exports file
-    // which contains the symbols needed for linking.
-    let nodeExpFile
-    let nodeRootDir
-    let candidates
-    let logprefix = 'find exports file'
-    if (process.platform === 'aix' || process.platform === 'os390' || process.platform === 'os400') {
-      const ext = process.platform === 'os390' ? 'x' : 'exp'
-      nodeRootDir = findNodeDirectory()
-
-      if (process.platform === 'aix' || process.platform === 'os400') {
-        candidates = [
-          'include/node/node',
-          'out/Release/node',
-          'out/Debug/node',
-          'node'
-        ].map(function (file) {
-          return file + '.' + ext
-        })
-      } else {
-        candidates = [
-          'out/Release/lib.target/libnode',
-          'out/Debug/lib.target/libnode',
-          'out/Release/obj.target/libnode',
-          'out/Debug/obj.target/libnode',
-          'lib/libnode'
-        ].map(function (file) {
-          return file + '.' + ext
-        })
-      }
-
-      nodeExpFile = findAccessibleSync(logprefix, nodeRootDir, candidates)
-      if (nodeExpFile !== undefined) {
-        log.verbose(logprefix, 'Found exports file: %s', nodeExpFile)
-      } else {
-        const msg = msgFormat('Could not find node.%s file in %s', ext, nodeRootDir)
-        log.error(logprefix, 'Could not find exports file')
-        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.
-    let zoslibIncDir
-    if (process.platform === 'os390') {
-      logprefix = "find zoslib's zos-base.h:"
-      let msg
-      let zoslibIncPath = process.env.ZOSLIB_INCLUDES
-      if (zoslibIncPath) {
-        zoslibIncPath = findAccessibleSync(logprefix, zoslibIncPath, ['zos-base.h'])
-        if (zoslibIncPath === undefined) {
-          msg = msgFormat('Could not find zos-base.h file in the directory set ' +
-                          'in ZOSLIB_INCLUDES environment variable: %s; set it ' +
-                          'to the correct path, or unset it to search %s', process.env.ZOSLIB_INCLUDES, nodeRootDir)
-        }
-      } else {
-        candidates = [
-          'include/node/zoslib/zos-base.h',
-          'include/zoslib/zos-base.h',
-          'zoslib/include/zos-base.h',
-          'install/include/node/zoslib/zos-base.h'
-        ]
-        zoslibIncPath = findAccessibleSync(logprefix, nodeRootDir, candidates)
-        if (zoslibIncPath === undefined) {
-          msg = msgFormat('Could not find any of %s in directory %s; set ' +
-                          'environmant variable ZOSLIB_INCLUDES to the path ' +
-                          'that contains zos-base.h', candidates.toString(), nodeRootDir)
-        }
-      }
-      if (zoslibIncPath !== undefined) {
-        zoslibIncDir = path.dirname(zoslibIncPath)
-        log.verbose(logprefix, "Found zoslib's zos-base.h in: %s", zoslibIncDir)
-      } else if (release.version.split('.')[0] >= 16) {
-        // zoslib is only shipped in Node v16 and above.
-        log.error(logprefix, msg)
-        throw new Error(msg)
-      }
-    }
-
-    // this logic ported from the old `gyp_addon` python file
-    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')
-    }
-
-    let outputDir = 'build'
-    if (win) {
-      // Windows expects an absolute path
-      outputDir = buildDir
-    }
-    const nodeGypDir = path.resolve(__dirname, '..')
-
-    let 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)
-
-    // 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')
-
-    // tell gyp to write the Makefile/Solution files into output_dir
-    argv.push('--generator-output', outputDir)
-
-    // tell make to write its output into the same dir
-    argv.push('-Goutput_dir=.')
-
-    // enforce use of the "binding.gyp" file
-    argv.unshift('binding.gyp')
-
-    // execute `gyp` from the current target nodedir
-    argv.unshift(gypScript)
-
-    // 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 ? ';' : ':')
-
-    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()
-        }
-      })
-    })
-  }
-}
-
-module.exports = configure
-module.exports.usage = 'Generates ' + (win ? 'MSVC project files' : 'a Makefile') + ' for the current module'