@dry-software/cmake-js 7.3.0

package/lib/runtimePaths.js

@@ -0,0 +1,95 @@
+'use strict'
+const assert = require('assert')
+const semver = require('semver')
+
+const NODE_MIRROR = process.env.NVM_NODEJS_ORG_MIRROR || 'https://nodejs.org/dist'
+const ELECTRON_MIRROR = process.env.ELECTRON_MIRROR || 'https://artifacts.electronjs.org/headers/dist'
+
+const runtimePaths = {
+	node: function (targetOptions) {
+		if (semver.lt(targetOptions.runtimeVersion, '4.0.0')) {
+			return {
+				externalPath: NODE_MIRROR + '/v' + targetOptions.runtimeVersion + '/',
+				winLibs: [
+					{
+						dir: targetOptions.isX64 ? 'x64' : '',
+						name: targetOptions.runtime + '.lib',
+					},
+				],
+				tarPath: targetOptions.runtime + '-v' + targetOptions.runtimeVersion + '.tar.gz',
+				headerOnly: false,
+			}
+		} else {
+			return {
+				externalPath: NODE_MIRROR + '/v' + targetOptions.runtimeVersion + '/',
+				winLibs: [
+					{
+						dir: targetOptions.isArm64 ? 'arm64' : targetOptions.isX64 ? 'win-x64' : 'win-x86',
+						name: targetOptions.runtime + '.lib',
+					},
+				],
+				tarPath: targetOptions.runtime + '-v' + targetOptions.runtimeVersion + '-headers.tar.gz',
+				headerOnly: true,
+			}
+		}
+	},
+	nw: function (targetOptions) {
+		if (semver.gte(targetOptions.runtimeVersion, '0.13.0')) {
+			return {
+				externalPath: 'https://node-webkit.s3.amazonaws.com/v' + targetOptions.runtimeVersion + '/',
+				winLibs: [
+					{
+						dir: targetOptions.isX64 ? 'x64' : '',
+						name: targetOptions.runtime + '.lib',
+					},
+					{
+						dir: targetOptions.isX64 ? 'x64' : '',
+						name: 'node.lib',
+					},
+				],
+				tarPath: 'nw-headers-v' + targetOptions.runtimeVersion + '.tar.gz',
+				headerOnly: false,
+			}
+		}
+		return {
+			externalPath: 'https://node-webkit.s3.amazonaws.com/v' + targetOptions.runtimeVersion + '/',
+			winLibs: [
+				{
+					dir: targetOptions.isX64 ? 'x64' : '',
+					name: targetOptions.runtime + '.lib',
+				},
+			],
+			tarPath: 'nw-headers-v' + targetOptions.runtimeVersion + '.tar.gz',
+			headerOnly: false,
+		}
+	},
+	electron: function (targetOptions) {
+		return {
+			externalPath: ELECTRON_MIRROR + '/v' + targetOptions.runtimeVersion + '/',
+			winLibs: [
+				{
+					dir: targetOptions.isX64 ? 'x64' : '',
+					name: 'node.lib',
+				},
+			],
+			tarPath: 'node' + '-v' + targetOptions.runtimeVersion + '.tar.gz',
+			headerOnly: semver.gte(targetOptions.runtimeVersion, '4.0.0-alpha'),
+		}
+	},
+	get: function (targetOptions) {
+		assert(targetOptions && typeof targetOptions === 'object')
+
+		const runtime = targetOptions.runtime
+		const func = runtimePaths[runtime]
+		let paths
+		if (typeof func === 'function') {
+			paths = func(targetOptions)
+			if (paths && typeof paths === 'object') {
+				return paths
+			}
+		}
+		throw new Error('Unknown runtime: ' + runtime)
+	},
+}
+
+module.exports = runtimePaths

package/lib/targetOptions.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const environment = require('./environment')
+
+class TargetOptions {
+	get arch() {
+		return this.options.arch || environment.arch
+	}
+	get isX86() {
+		return this.arch === 'ia32' || this.arch === 'x86'
+	}
+	get isX64() {
+		return this.arch === 'x64'
+	}
+	get isArm() {
+		return this.arch === 'arm'
+	}
+	get isArm64() {
+		return this.arch === 'arm64'
+	}
+	get runtime() {
+		return this.options.runtime || environment.runtime
+	}
+	get runtimeVersion() {
+		return this.options.runtimeVersion || environment.runtimeVersion
+	}
+
+	constructor(options) {
+		this.options = options || {}
+	}
+}
+
+module.exports = TargetOptions

package/lib/toolset.js

@@ -0,0 +1,224 @@
+'use strict'
+const TargetOptions = require('./targetOptions')
+const environment = require('./environment')
+const assert = require('assert')
+const CMLog = require('./cmLog')
+const { findVisualStudio } = environment.isWin ? require('./import/find-visualstudio') : {}
+
+class Toolset {
+	constructor(options) {
+		this.options = options || {}
+		this.targetOptions = new TargetOptions(this.options)
+		this.generator = options.generator
+		this.toolset = options.toolset
+		this.platform = options.platform
+		this.target = options.target
+		this.cCompilerPath = options.cCompilerPath
+		this.cppCompilerPath = options.cppCompilerPath
+		this.compilerFlags = []
+		this.linkerFlags = []
+		this.makePath = null
+		this.log = new CMLog(this.options)
+		this._initialized = false
+	}
+	async initialize(install) {
+		if (!this._initialized) {
+			if (environment.isWin) {
+				await this.initializeWin(install)
+			} else {
+				this.initializePosix(install)
+			}
+			this._initialized = true
+		}
+	}
+	initializePosix(install) {
+		if (!this.cCompilerPath || !this.cppCompilerPath) {
+			// 1: Compiler
+			if (!environment.isGPPAvailable && !environment.isClangAvailable) {
+				if (environment.isOSX) {
+					throw new Error(
+						"C++ Compiler toolset is not available. Install Xcode Commandline Tools from Apple Dev Center, or install Clang with homebrew by invoking: 'brew install llvm --with-clang --with-asan'.",
+					)
+				} else {
+					throw new Error(
+						"C++ Compiler toolset is not available. Install proper compiler toolset with your package manager, eg. 'sudo apt-get install g++'.",
+					)
+				}
+			}
+
+			if (this.options.preferClang && environment.isClangAvailable) {
+				if (install) {
+					this.log.info('TOOL', 'Using clang++ compiler, because preferClang option is set, and clang++ is available.')
+				}
+				this.cppCompilerPath = this.cppCompilerPath || 'clang++'
+				this.cCompilerPath = this.cCompilerPath || 'clang'
+			} else if (this.options.preferGnu && environment.isGPPAvailable) {
+				if (install) {
+					this.log.info('TOOL', 'Using g++ compiler, because preferGnu option is set, and g++ is available.')
+				}
+				this.cppCompilerPath = this.cppCompilerPath || 'g++'
+				this.cCompilerPath = this.cCompilerPath || 'gcc'
+			}
+		}
+		// if it's already set because of options...
+		if (this.generator) {
+			if (install) {
+				this.log.info('TOOL', 'Using ' + this.generator + ' generator, as specified from commandline.')
+			}
+		}
+
+		// 2: Generator
+		else if (environment.isOSX) {
+			if (this.options.preferXcode) {
+				if (install) {
+					this.log.info('TOOL', 'Using Xcode generator, because preferXcode option is set.')
+				}
+				this.generator = 'Xcode'
+			} else if (this.options.preferMake && environment.isMakeAvailable) {
+				if (install) {
+					this.log.info(
+						'TOOL',
+						'Using Unix Makefiles generator, because preferMake option is set, and make is available.',
+					)
+				}
+				this.generator = 'Unix Makefiles'
+			} else if (environment.isNinjaAvailable) {
+				if (install) {
+					this.log.info('TOOL', 'Using Ninja generator, because ninja is available.')
+				}
+				this.generator = 'Ninja'
+			} else {
+				if (install) {
+					this.log.info('TOOL', 'Using Unix Makefiles generator.')
+				}
+				this.generator = 'Unix Makefiles'
+			}
+		} else {
+			if (this.options.preferMake && environment.isMakeAvailable) {
+				if (install) {
+					this.log.info(
+						'TOOL',
+						'Using Unix Makefiles generator, because preferMake option is set, and make is available.',
+					)
+				}
+				this.generator = 'Unix Makefiles'
+			} else if (environment.isNinjaAvailable) {
+				if (install) {
+					this.log.info('TOOL', 'Using Ninja generator, because ninja is available.')
+				}
+				this.generator = 'Ninja'
+			} else {
+				if (install) {
+					this.log.info('TOOL', 'Using Unix Makefiles generator.')
+				}
+				this.generator = 'Unix Makefiles'
+			}
+		}
+
+		// 3: Flags
+		if (environment.isOSX) {
+			if (install) {
+				this.log.verbose('TOOL', 'Setting default OSX compiler flags.')
+			}
+
+			this.compilerFlags.push('-D_DARWIN_USE_64_BIT_INODE=1')
+			this.compilerFlags.push('-D_LARGEFILE_SOURCE')
+			this.compilerFlags.push('-D_FILE_OFFSET_BITS=64')
+			this.linkerFlags.push('-undefined dynamic_lookup')
+		}
+
+		this.compilerFlags.push('-DBUILDING_NODE_EXTENSION')
+
+		// 4: Build target
+		if (this.options.target) {
+			this.log.info('TOOL', 'Building only the ' + this.options.target + ' target, as specified from the command line.')
+		}
+	}
+	async initializeWin(install) {
+		if (!this.generator) {
+			const foundVsInfo = await this._getTopSupportedVisualStudioGenerator()
+			if (foundVsInfo) {
+				if (install) {
+					this.log.info('TOOL', `Using ${foundVsInfo.generator} generator.`)
+				}
+				this.generator = foundVsInfo.generator
+
+				const isAboveVS16 = foundVsInfo.versionMajor >= 16
+
+				// The CMake Visual Studio Generator does not support the Win64 or ARM suffix on
+				// the generator name. Instead the generator platform must be set explicitly via
+				// the platform parameter
+				if (!this.platform && isAboveVS16) {
+					switch (this.targetOptions.arch) {
+						case 'ia32':
+						case 'x86':
+							this.platform = 'Win32'
+							break
+						case 'x64':
+							this.platform = 'x64'
+							break
+						case 'arm':
+							this.platform = 'ARM'
+							break
+						case 'arm64':
+							this.platform = 'ARM64'
+							break
+						default:
+							this.log.warn('TOOL', 'Unknown NodeJS architecture: ' + this.targetOptions.arch)
+							break
+					}
+				}
+			} else {
+				throw new Error('There is no Visual C++ compiler installed. Install Visual C++ Build Toolset or Visual Studio.')
+			}
+		} else {
+			// if it's already set because of options...
+			if (install) {
+				this.log.info('TOOL', 'Using ' + this.options.generator + ' generator, as specified from commandline.')
+			}
+		}
+
+		this.linkerFlags.push('/DELAYLOAD:NODE.EXE')
+
+		if (this.targetOptions.isX86) {
+			if (install) {
+				this.log.verbose('TOOL', 'Setting SAFESEH:NO linker flag.')
+			}
+			this.linkerFlags.push('/SAFESEH:NO')
+		}
+	}
+	async _getTopSupportedVisualStudioGenerator() {
+		const CMake = require('./cMake')
+		assert(environment.isWin)
+
+		const selectedVs = await findVisualStudio(environment.runtimeVersion, this.options.msvsVersion)
+		if (!selectedVs) return null
+
+		const list = await CMake.getGenerators(this.options, this.log)
+		for (const gen of list) {
+			const found = gen.startsWith(`Visual Studio ${selectedVs.versionMajor}`)
+			if (!found) {
+				continue
+			}
+
+			// unlike previous versions "Visual Studio 16 2019" and onwards don't end with arch name
+			const isAboveVS16 = selectedVs.versionMajor >= 16
+			if (!isAboveVS16) {
+				const is64Bit = gen.endsWith('Win64')
+				if ((this.targetOptions.isX86 && is64Bit) || (this.targetOptions.isX64 && !is64Bit)) {
+					continue
+				}
+			}
+
+			return {
+				...selectedVs,
+				generator: gen,
+			}
+		}
+
+		// Nothing matched
+		return null
+	}
+}
+
+module.exports = Toolset

package/package.json

@@ -0,0 +1,76 @@
+{
+	"name": "@dry-software/cmake-js",
+	"description": "CMake.js - a Node.js native addon build tool",
+	"license": "MIT",
+	"keywords": [
+		"native",
+		"addon",
+		"module",
+		"c",
+		"c++",
+		"bindings",
+		"build",
+		"buildtools",
+		"cmake",
+		"nw.js",
+		"electron",
+		"boost",
+		"nan",
+		"napi",
+		"node-api",
+		"node-addon-api"
+	],
+	"main": "lib",
+	"version": "7.3.0",
+	"author": "Gábor Mező aka unbornchikken",
+	"maintainers": [
+		{
+			"name": "dry Software UG (haftungsbeschränkt)",
+			"email": "info@dry.software",
+			"url": "https://dry.software"
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/cmake-js/cmake-js.git"
+	},
+	"bin": {
+		"cmake-js": "./bin/cmake-js"
+	},
+	"engines": {
+		"node": ">= 14.15.0"
+	},
+	"dependencies": {
+		"axios": "^1.6.5",
+		"debug": "^4",
+		"fs-extra": "^11.2.0",
+		"memory-stream": "^1.0.0",
+		"node-api-headers": "^1.1.0",
+		"npmlog": "^6.0.2",
+		"rc": "^1.2.7",
+		"semver": "^7.5.4",
+		"tar": "^6.2.0",
+		"url-join": "^4.0.1",
+		"which": "^2.0.2",
+		"yargs": "^17.7.2"
+	},
+	"devDependencies": {
+		"eslint": "^8.56.0",
+		"eslint-config-prettier": "^9.1.0",
+		"mocha": "*",
+		"nan": "^2.18.0",
+		"node-addon-api": "^6.1.0",
+		"prettier": "^3.2.2"
+	},
+	"scripts": {
+		"test": "mocha tests",
+		"lint": "eslint lib bin/cmake-js tests"
+	},
+	"files": [
+		"lib",
+		"bin",
+		"*.md",
+		"bindings.js",
+		"bindings.d.ts"
+	]
+}