pnpm 11.23.0 → 11.24.0

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

@@ -1,606 +0,0 @@
-'use strict'
-
-const log = require('./log')
-const { existsSync } = require('fs')
-const { win32: path } = require('path')
-const { regSearchKeys, execFile } = require('./util')
-
-class VisualStudioFinder {
-  static findVisualStudio = (...args) => new VisualStudioFinder(...args).findVisualStudio()
-
-  log = log.withPrefix('find VS')
-
-  regSearchKeys = regSearchKeys
-
-  constructor (nodeSemver, configMsvsVersion) {
-    this.nodeSemver = nodeSemver
-    this.configMsvsVersion = configMsvsVersion
-    this.errorLog = []
-    this.validVersions = []
-  }
-
-  // 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 (message) {
-    this.log.verbose(message)
-    this.errorLog.push(message)
-  }
-
-  async findVisualStudio () {
-    this.configVersionYear = null
-    this.configPath = null
-    if (this.configMsvsVersion) {
-      this.addLog(`--msvs_version=${this.configMsvsVersion} was set on the command line`)
-      if (this.configMsvsVersion.match(/^\d{4}$/)) {
-        this.configVersionYear = parseInt(this.configMsvsVersion, 10)
-        this.addLog(
-          `- looking for Visual Studio version ${this.configVersionYear}`)
-      } else {
-        this.configPath = path.resolve(this.configMsvsVersion)
-        this.addLog(
-          `- looking for Visual Studio installed in "${this.configPath}"`)
-      }
-    } else {
-      this.addLog('--msvs_version was not set on the command line')
-    }
-
-    if (process.env.VCINSTALLDIR) {
-      this.envVcInstallDir =
-        path.resolve(process.env.VCINSTALLDIR, '..')
-      this.addLog('running in VS Command Prompt, installation path is:\n' +
-        `"${this.envVcInstallDir}"\n- will only use this version`)
-    } else {
-      this.addLog('VCINSTALLDIR not set, not running in VS Command Prompt')
-    }
-
-    const checks = [
-      () => this.findVisualStudio2019OrNewerFromSpecifiedLocation(),
-      () => this.findVisualStudio2019OrNewerUsingSetupModule(),
-      () => this.findVisualStudio2019OrNewer(),
-      () => this.findVisualStudio2017FromSpecifiedLocation(),
-      () => this.findVisualStudio2017UsingSetupModule(),
-      () => this.findVisualStudio2017(),
-      () => this.findVisualStudio2015(),
-      () => this.findVisualStudio2013()
-    ]
-
-    for (const check of checks) {
-      const info = await check()
-      if (info) {
-        return this.succeed(info)
-      }
-    }
-
-    return this.fail()
-  }
-
-  succeed (info) {
-    this.log.info(`using VS${info.versionYear} (${info.version}) found at:` +
-                  `\n"${info.path}"` +
-                  '\nrun with --verbose for detailed information')
-    return info
-  }
-
-  fail () {
-    if (this.configMsvsVersion && this.envVcInstallDir) {
-      this.errorLog.push(
-        'msvs_version does not match this VS Command Prompt or the',
-        'installation cannot be used.')
-    } else if (this.configMsvsVersion) {
-      // If msvs_version was specified but finding VS failed, print what would
-      // have been accepted
-      this.errorLog.push('')
-      if (this.validVersions) {
-        this.errorLog.push('valid versions for msvs_version:')
-        this.validVersions.forEach((version) => {
-          this.errorLog.push(`- "${version}"`)
-        })
-      } else {
-        this.errorLog.push('no valid versions for msvs_version were found')
-      }
-    }
-
-    const errorLog = this.errorLog.join('\n')
-
-    // For Windows 80 col console, use up to the column before the one marked
-    // with X (total 79 chars including logger prefix, 62 chars usable here):
-    //                                                               X
-    const infoLog = [
-      '**************************************************************',
-      'You need to install the latest version of Visual Studio',
-      'including the "Desktop development with C++" workload.',
-      'For more information consult the documentation at:',
-      'https://github.com/nodejs/node-gyp#on-windows',
-      '**************************************************************'
-    ].join('\n')
-
-    this.log.error(`\n${errorLog}\n\n${infoLog}\n`)
-    throw new Error('Could not find any Visual Studio installation to use')
-  }
-
-  async findVisualStudio2019OrNewerFromSpecifiedLocation () {
-    return this.findVSFromSpecifiedLocation([2019, 2022, 2026])
-  }
-
-  async findVisualStudio2017FromSpecifiedLocation () {
-    if (this.nodeSemver.major >= 22) {
-      this.addLog(
-        'not looking for VS2017 as it is only supported up to Node.js 21')
-      return null
-    }
-    return this.findVSFromSpecifiedLocation([2017])
-  }
-
-  async findVSFromSpecifiedLocation (supportedYears) {
-    if (!this.envVcInstallDir) {
-      return null
-    }
-    const info = {
-      path: path.resolve(this.envVcInstallDir),
-      // Assume the version specified by the user is correct.
-      // Since Visual Studio 2015, the Developer Command Prompt sets the
-      // VSCMD_VER environment variable which contains the version information
-      // for Visual Studio.
-      // https://learn.microsoft.com/en-us/visualstudio/ide/reference/command-prompt-powershell?view=vs-2022
-      version: process.env.VSCMD_VER,
-      packages: [
-        'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
-        'Microsoft.VisualStudio.Component.VC.Tools.ARM64',
-        // Assume MSBuild exists. It will be checked in processing.
-        'Microsoft.VisualStudio.VC.MSBuild.Base'
-      ]
-    }
-
-    // Is there a better way to get SDK information?
-    const envWindowsSDKVersion = process.env.WindowsSDKVersion
-    const sdkVersionMatched = envWindowsSDKVersion?.match(/^(\d+)\.(\d+)\.(\d+)\..*/)
-    if (sdkVersionMatched) {
-      info.packages.push(`Microsoft.VisualStudio.Component.Windows10SDK.${sdkVersionMatched[3]}.Desktop`)
-    }
-    // pass for further processing
-    return this.processData([info], supportedYears)
-  }
-
-  async findVisualStudio2019OrNewerUsingSetupModule () {
-    return this.findNewVSUsingSetupModule([2019, 2022, 2026])
-  }
-
-  async findVisualStudio2017UsingSetupModule () {
-    if (this.nodeSemver.major >= 22) {
-      this.addLog(
-        'not looking for VS2017 as it is only supported up to Node.js 21')
-      return null
-    }
-    return this.findNewVSUsingSetupModule([2017])
-  }
-
-  async findNewVSUsingSetupModule (supportedYears) {
-    const ps = path.join(process.env.SystemRoot, 'System32',
-      'WindowsPowerShell', 'v1.0', 'powershell.exe')
-    const vcInstallDir = this.envVcInstallDir
-
-    const checkModuleArgs = [
-      '-NoProfile',
-      '-Command',
-      '&{@(Get-Module -ListAvailable -Name VSSetup).Version.ToString()}'
-    ]
-    this.log.silly('Running', ps, checkModuleArgs)
-    const [cErr] = await this.execFile(ps, checkModuleArgs)
-    if (cErr) {
-      this.addLog('VSSetup module doesn\'t seem to exist. You can install it via: "Install-Module VSSetup -Scope CurrentUser"')
-      this.log.silly('VSSetup error = %j', cErr && (cErr.stack || cErr))
-      return null
-    }
-    const filterArg = vcInstallDir !== undefined ? `| where {$_.InstallationPath -eq '${vcInstallDir}' }` : ''
-    const psArgs = [
-      '-NoProfile',
-      '-Command',
-      `&{Get-VSSetupInstance ${filterArg} | ConvertTo-Json -Depth 3}`
-    ]
-
-    this.log.silly('Running', ps, psArgs)
-    const [err, stdout, stderr] = await this.execFile(ps, psArgs)
-    let parsedData = this.parseData(err, stdout, stderr)
-    if (parsedData === null) {
-      return null
-    }
-    this.log.silly('Parsed data', parsedData)
-    if (!Array.isArray(parsedData)) {
-      // if there are only 1 result, then Powershell will output non-array
-      parsedData = [parsedData]
-    }
-    // normalize output
-    parsedData = parsedData.map((info) => {
-      info.path = info.InstallationPath
-      info.version = `${info.InstallationVersion.Major}.${info.InstallationVersion.Minor}.${info.InstallationVersion.Build}.${info.InstallationVersion.Revision}`
-      info.packages = info.Packages.map((p) => p.Id)
-      return info
-    })
-    // pass for further processing
-    return this.processData(parsedData, supportedYears)
-  }
-
-  // Invoke the PowerShell script to get information about Visual Studio 2019
-  // or newer installations
-  async findVisualStudio2019OrNewer () {
-    return this.findNewVS([2019, 2022, 2026])
-  }
-
-  // Invoke the PowerShell script to get information about Visual Studio 2017
-  async findVisualStudio2017 () {
-    if (this.nodeSemver.major >= 22) {
-      this.addLog(
-        'not looking for VS2017 as it is only supported up to Node.js 21')
-      return null
-    }
-    return this.findNewVS([2017])
-  }
-
-  // Invoke the PowerShell script to get information about Visual Studio 2017
-  // or newer installations
-  async findNewVS (supportedYears) {
-    const ps = path.join(process.env.SystemRoot, 'System32',
-      'WindowsPowerShell', 'v1.0', 'powershell.exe')
-    const csFile = path.join(__dirname, 'Find-VisualStudio.cs')
-    const psArgs = [
-      '-ExecutionPolicy',
-      'Unrestricted',
-      '-NoProfile',
-      '-Command',
-      '&{Add-Type -IgnoreWarnings -Path \'' + csFile + '\';' + '[VisualStudioConfiguration.Main]::PrintJson()}'
-    ]
-
-    this.log.silly('Running', ps, psArgs)
-    const [err, stdout, stderr] = await this.execFile(ps, psArgs)
-    const parsedData = this.parseData(err, stdout, stderr, { checkIsArray: true })
-    if (parsedData === null) {
-      return null
-    }
-    return this.processData(parsedData, supportedYears)
-  }
-
-  // Parse the output of the PowerShell script, make sanity checks
-  parseData (err, stdout, stderr, sanityCheckOptions) {
-    const defaultOptions = {
-      checkIsArray: false
-    }
-
-    // Merging provided options with the default options
-    const sanityOptions = { ...defaultOptions, ...sanityCheckOptions }
-
-    this.log.silly('PS stderr = %j', stderr)
-
-    const failPowershell = (failureDetails) => {
-      this.addLog(
-        `could not use PowerShell to find Visual Studio 2017 or newer, try re-running with '--loglevel silly' for more details. \n
-        Failure details: ${failureDetails}`)
-      return null
-    }
-
-    if (err) {
-      this.log.silly('PS err = %j', err && (err.stack || err))
-      return failPowershell(`${err}`.substring(0, 40))
-    }
-
-    let vsInfo
-    try {
-      vsInfo = JSON.parse(stdout)
-    } catch (e) {
-      this.log.silly('PS stdout = %j', stdout)
-      this.log.silly(e)
-      return failPowershell()
-    }
-
-    if (sanityOptions.checkIsArray && !Array.isArray(vsInfo)) {
-      this.log.silly('PS stdout = %j', stdout)
-      return failPowershell('Expected array as output of the PS script')
-    }
-    return vsInfo
-  }
-
-  // Process parsed data containing information about VS installations
-  // Look for the required parts, extract and output them back
-  processData (vsInfo, supportedYears) {
-    vsInfo = vsInfo.map((info) => {
-      this.log.silly(`processing installation: "${info.path}"`)
-      info.path = path.resolve(info.path)
-      const ret = this.getVersionInfo(info)
-      ret.path = info.path
-      ret.msBuild = this.getMSBuild(info, ret.versionYear)
-      ret.toolset = this.getToolset(info, ret.versionYear)
-      ret.sdk = this.getSDK(info)
-      return ret
-    })
-    this.log.silly('vsInfo:', vsInfo)
-
-    // Remove future versions or errors parsing version number
-    // Also remove any unsupported versions
-    vsInfo = vsInfo.filter((info) => {
-      if (info.versionYear && supportedYears.indexOf(info.versionYear) !== -1) {
-        return true
-      }
-      this.addLog(`${info.versionYear ? 'unsupported' : 'unknown'} version "${info.version}" found at "${info.path}"`)
-      return false
-    })
-
-    // Sort to place newer versions first
-    vsInfo.sort((a, b) => b.versionYear - a.versionYear)
-
-    for (let i = 0; i < vsInfo.length; ++i) {
-      const info = vsInfo[i]
-      this.addLog(`checking VS${info.versionYear} (${info.version}) found ` +
-                  `at:\n"${info.path}"`)
-
-      if (info.msBuild) {
-        this.addLog('- found "Visual Studio C++ core features"')
-      } else {
-        this.addLog('- "Visual Studio C++ core features" missing')
-        continue
-      }
-
-      if (info.toolset) {
-        this.addLog(`- found VC++ toolset: ${info.toolset}`)
-      } else {
-        this.addLog('- missing any VC++ toolset')
-        continue
-      }
-
-      if (info.sdk) {
-        this.addLog(`- found Windows SDK: ${info.sdk}`)
-      } else {
-        this.addLog('- missing any Windows SDK')
-        continue
-      }
-
-      if (!this.checkConfigVersion(info.versionYear, info.path)) {
-        continue
-      }
-
-      return info
-    }
-
-    this.addLog(
-      'could not find a version of Visual Studio 2017 or newer to use')
-    return null
-  }
-
-  // Helper - process version information
-  getVersionInfo (info) {
-    const match = /^(\d+)\.(\d+)(?:\..*)?/.exec(info.version)
-    if (!match) {
-      this.log.silly('- failed to parse version:', info.version)
-      return {}
-    }
-    this.log.silly('- version match = %j', match)
-    const ret = {
-      version: info.version,
-      versionMajor: parseInt(match[1], 10),
-      versionMinor: parseInt(match[2], 10)
-    }
-    if (ret.versionMajor === 15) {
-      ret.versionYear = 2017
-      return ret
-    }
-    if (ret.versionMajor === 16) {
-      ret.versionYear = 2019
-      return ret
-    }
-    if (ret.versionMajor === 17) {
-      ret.versionYear = 2022
-      return ret
-    }
-    if (ret.versionMajor === 18) {
-      ret.versionYear = 2026
-      return ret
-    }
-    this.log.silly('- unsupported version:', ret.versionMajor)
-    return {}
-  }
-
-  msBuildPathExists (path) {
-    return existsSync(path)
-  }
-
-  // Helper - process MSBuild information
-  getMSBuild (info, versionYear) {
-    const pkg = 'Microsoft.VisualStudio.VC.MSBuild.Base'
-    const msbuildPath = path.join(info.path, 'MSBuild', 'Current', 'Bin', 'MSBuild.exe')
-    const msbuildPathArm64 = path.join(info.path, 'MSBuild', 'Current', 'Bin', 'arm64', 'MSBuild.exe')
-    if (info.packages.indexOf(pkg) !== -1) {
-      this.log.silly('- found VC.MSBuild.Base')
-      if (versionYear === 2017) {
-        return path.join(info.path, 'MSBuild', '15.0', 'Bin', 'MSBuild.exe')
-      }
-      if (versionYear === 2019) {
-        if (process.arch === 'arm64' && this.msBuildPathExists(msbuildPathArm64)) {
-          return msbuildPathArm64
-        } else {
-          return msbuildPath
-        }
-      }
-    }
-    /**
-     * Visual Studio 2022 doesn't have the MSBuild package.
-     * Support for compiling _on_ ARM64 was added in MSVC 14.32.31326,
-     * so let's leverage it if the user has an ARM64 device.
-     */
-    if (process.arch === 'arm64' && this.msBuildPathExists(msbuildPathArm64)) {
-      return msbuildPathArm64
-    } else if (this.msBuildPathExists(msbuildPath)) {
-      return msbuildPath
-    }
-    return null
-  }
-
-  // Helper - process toolset information
-  getToolset (info, versionYear) {
-    const vcToolsArm64 = 'VC.Tools.ARM64'
-    const pkgArm64 = `Microsoft.VisualStudio.Component.${vcToolsArm64}`
-    const vcToolsX64 = 'VC.Tools.x86.x64'
-    const pkgX64 = `Microsoft.VisualStudio.Component.${vcToolsX64}`
-    const express = 'Microsoft.VisualStudio.WDExpress'
-
-    if (process.arch === 'arm64' && info.packages.includes(pkgArm64)) {
-      this.log.silly(`- found ${vcToolsArm64}`)
-    } else if (info.packages.includes(pkgX64)) {
-      if (process.arch === 'arm64') {
-        this.addLog(`- found ${vcToolsX64} on ARM64 platform. Expect less performance and/or link failure with ARM64 binary.`)
-      } else {
-        this.log.silly(`- found ${vcToolsX64}`)
-      }
-    } else if (info.packages.includes(express)) {
-      this.log.silly('- found Visual Studio Express (looking for toolset)')
-    } else {
-      return null
-    }
-
-    if (versionYear === 2017) {
-      return 'v141'
-    } else if (versionYear === 2019) {
-      return 'v142'
-    } else if (versionYear === 2022) {
-      return 'v143'
-    } else if (versionYear === 2026) {
-      return 'v145'
-    }
-    this.log.silly('- invalid versionYear:', versionYear)
-    return null
-  }
-
-  // Helper - process Windows SDK information
-  getSDK (info) {
-    const win8SDK = 'Microsoft.VisualStudio.Component.Windows81SDK'
-    const win10SDKPrefix = 'Microsoft.VisualStudio.Component.Windows10SDK.'
-    const win11SDKPrefix = 'Microsoft.VisualStudio.Component.Windows11SDK.'
-
-    let Win10or11SDKVer = 0
-    info.packages.forEach((pkg) => {
-      if (!pkg.startsWith(win10SDKPrefix) && !pkg.startsWith(win11SDKPrefix)) {
-        return
-      }
-      const parts = pkg.split('.')
-      if (parts.length > 5 && parts[5] !== 'Desktop') {
-        this.log.silly('- ignoring non-Desktop Win10/11SDK:', pkg)
-        return
-      }
-      const foundSdkVer = parseInt(parts[4], 10)
-      if (isNaN(foundSdkVer)) {
-        // Microsoft.VisualStudio.Component.Windows10SDK.IpOverUsb
-        this.log.silly('- failed to parse Win10/11SDK number:', pkg)
-        return
-      }
-      this.log.silly('- found Win10/11SDK:', foundSdkVer)
-      Win10or11SDKVer = Math.max(Win10or11SDKVer, foundSdkVer)
-    })
-
-    if (Win10or11SDKVer !== 0) {
-      return `10.0.${Win10or11SDKVer}.0`
-    } else if (info.packages.indexOf(win8SDK) !== -1) {
-      this.log.silly('- found Win8SDK')
-      return '8.1'
-    }
-    return null
-  }
-
-  // Find an installation of Visual Studio 2015 to use
-  async findVisualStudio2015 () {
-    if (this.nodeSemver.major >= 19) {
-      this.addLog(
-        'not looking for VS2015 as it is only supported up to Node.js 18')
-      return null
-    }
-    return this.findOldVS({
-      version: '14.0',
-      versionMajor: 14,
-      versionMinor: 0,
-      versionYear: 2015,
-      toolset: 'v140'
-    })
-  }
-
-  // Find an installation of Visual Studio 2013 to use
-  async findVisualStudio2013 () {
-    if (this.nodeSemver.major >= 9) {
-      this.addLog(
-        'not looking for VS2013 as it is only supported up to Node.js 8')
-      return null
-    }
-    return this.findOldVS({
-      version: '12.0',
-      versionMajor: 12,
-      versionMinor: 0,
-      versionYear: 2013,
-      toolset: 'v120'
-    })
-  }
-
-  // Helper - common code for VS2013 and VS2015
-  async findOldVS (info) {
-    const regVC7 = ['HKLM\\Software\\Microsoft\\VisualStudio\\SxS\\VC7',
-      'HKLM\\Software\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VC7']
-    const regMSBuild = 'HKLM\\Software\\Microsoft\\MSBuild\\ToolsVersions'
-
-    this.addLog(`looking for Visual Studio ${info.versionYear}`)
-    try {
-      let res = await this.regSearchKeys(regVC7, info.version, [])
-      const vsPath = path.resolve(res, '..')
-      this.addLog(`- found in "${vsPath}"`)
-      const msBuildRegOpts = process.arch === 'ia32' ? [] : ['/reg:32']
-
-      try {
-        res = await this.regSearchKeys([`${regMSBuild}\\${info.version}`], 'MSBuildToolsPath', msBuildRegOpts)
-      } catch (err) {
-        this.addLog('- could not find MSBuild in registry for this version')
-        return null
-      }
-
-      const msBuild = path.join(res, 'MSBuild.exe')
-      this.addLog(`- MSBuild in "${msBuild}"`)
-
-      if (!this.checkConfigVersion(info.versionYear, vsPath)) {
-        return null
-      }
-
-      info.path = vsPath
-      info.msBuild = msBuild
-      info.sdk = null
-      return info
-    } catch (err) {
-      this.addLog('- not found')
-      return null
-    }
-  }
-
-  // After finding a usable version of Visual Studio:
-  // - add it to validVersions to be displayed at the end if a specific
-  //   version was requested and not found;
-  // - check if this is the version that was requested.
-  // - check if this matches the Visual Studio Command Prompt
-  checkConfigVersion (versionYear, vsPath) {
-    this.validVersions.push(versionYear)
-    this.validVersions.push(vsPath)
-
-    if (this.configVersionYear && this.configVersionYear !== versionYear) {
-      this.addLog('- msvs_version does not match this version')
-      return false
-    }
-    if (this.configPath &&
-        path.relative(this.configPath, vsPath) !== '') {
-      this.addLog('- msvs_version does not point to this installation')
-      return false
-    }
-    if (this.envVcInstallDir &&
-        path.relative(this.envVcInstallDir, vsPath) !== '') {
-      this.addLog('- does not match this Visual Studio Command Prompt')
-      return false
-    }
-
-    return true
-  }
-
-  async execFile (exec, args) {
-    return await execFile(exec, args, { encoding: 'utf8' })
-  }
-}
-
-module.exports = VisualStudioFinder