158 lines
3.9 KiB
TypeScript
158 lines
3.9 KiB
TypeScript
import os from 'os'
|
|
import { join, parse, sep } from 'path'
|
|
|
|
import chalk from 'chalk'
|
|
import { Command } from 'clipanion'
|
|
import toml from 'toml'
|
|
|
|
import { getNapiConfig } from './consts'
|
|
import { debugFactory } from './debug'
|
|
import { existsAsync, readFileAsync, writeFileAsync } from './utils'
|
|
|
|
const debug = debugFactory('build')
|
|
|
|
export class BuildCommand extends Command {
|
|
static usage = Command.Usage({
|
|
description: 'Copy native module into specified dir',
|
|
})
|
|
|
|
@Command.Boolean(`--platform`)
|
|
appendPlatformToFilename!: boolean
|
|
|
|
@Command.Boolean(`--release`)
|
|
isRelease = false
|
|
|
|
@Command.Boolean('--musl')
|
|
isMusl = false
|
|
|
|
@Command.String('--config,-c')
|
|
configFileName?: string
|
|
|
|
@Command.String('--cargo-name')
|
|
cargoName?: string
|
|
|
|
@Command.String('--target-triple')
|
|
targetTripleDir = ''
|
|
|
|
@Command.String({
|
|
required: false,
|
|
})
|
|
target = '.'
|
|
|
|
@Command.Path('build')
|
|
async execute() {
|
|
const { binaryName } = getNapiConfig(this.configFileName)
|
|
let dylibName = this.cargoName
|
|
if (!dylibName) {
|
|
let tomlContentString: string
|
|
let tomlContent: any
|
|
try {
|
|
debug('Start read toml')
|
|
tomlContentString = await readFileAsync(
|
|
join(process.cwd(), 'Cargo.toml'),
|
|
'utf-8',
|
|
)
|
|
} catch {
|
|
throw new TypeError(`Could not find Cargo.toml in ${process.cwd()}`)
|
|
}
|
|
|
|
try {
|
|
debug('Start parse toml')
|
|
tomlContent = toml.parse(tomlContentString)
|
|
} catch {
|
|
throw new TypeError('Could not parse the Cargo.toml')
|
|
}
|
|
|
|
if (tomlContent.package?.name) {
|
|
dylibName = tomlContent.package.name.replace(/-/g, '_')
|
|
} else {
|
|
throw new TypeError('No package.name field in Cargo.toml')
|
|
}
|
|
}
|
|
|
|
debug(`Dylib name: ${chalk.greenBright(dylibName)}`)
|
|
|
|
const platform = os.platform()
|
|
let libExt
|
|
|
|
debug(`Platform: ${chalk.greenBright(platform)}`)
|
|
|
|
// Platform based massaging for build commands
|
|
switch (platform) {
|
|
case 'darwin':
|
|
libExt = '.dylib'
|
|
dylibName = `lib${dylibName}`
|
|
break
|
|
case 'win32':
|
|
libExt = '.dll'
|
|
break
|
|
case 'linux':
|
|
case 'freebsd':
|
|
dylibName = `lib${dylibName}`
|
|
libExt = '.so'
|
|
break
|
|
default:
|
|
throw new TypeError(
|
|
'Operating system not currently supported or recognized by the build script',
|
|
)
|
|
}
|
|
|
|
const targetDir = join(
|
|
this.targetTripleDir,
|
|
this.isRelease ? 'release' : 'debug',
|
|
)
|
|
|
|
if (this.isMusl && !this.appendPlatformToFilename) {
|
|
throw new TypeError(`Musl flag must be used with platform flag`)
|
|
}
|
|
|
|
const platformName = this.appendPlatformToFilename
|
|
? !this.isMusl
|
|
? `.${platform}`
|
|
: `.${platform}-musl`
|
|
: ''
|
|
|
|
debug(
|
|
`Platform name: ${
|
|
platformName || chalk.green('[Empty]')
|
|
}, musl: ${chalk.greenBright(this.isMusl)}`,
|
|
)
|
|
|
|
let distModulePath = this.target
|
|
? join(this.target, `${binaryName}${platformName}.node`)
|
|
: join('target', targetDir, `${binaryName}${platformName}.node`)
|
|
const parsedDist = parse(distModulePath)
|
|
|
|
if (!parsedDist.ext) {
|
|
distModulePath = `${distModulePath}${platformName}.node`
|
|
}
|
|
|
|
const dir = await findUp()
|
|
|
|
if (!dir) {
|
|
throw new TypeError('No target dir found')
|
|
}
|
|
|
|
const sourcePath = join(dir, 'target', targetDir, `${dylibName}${libExt}`)
|
|
debug(`Read [${chalk.yellowBright(sourcePath)}] content`)
|
|
|
|
const dylibContent = await readFileAsync(sourcePath)
|
|
|
|
debug(`Write binary content to [${chalk.yellowBright(distModulePath)}]`)
|
|
|
|
await writeFileAsync(distModulePath, dylibContent)
|
|
}
|
|
}
|
|
|
|
async function findUp(dir = process.cwd()): Promise<string | null> {
|
|
const dist = join(dir, 'target')
|
|
if (await existsAsync(dist)) {
|
|
return dir
|
|
}
|
|
const dirs = dir.split(sep)
|
|
if (dirs.length < 2) {
|
|
return null
|
|
}
|
|
dirs.pop()
|
|
return findUp(dirs.join(sep))
|
|
}
|