@napi-rs/cli 3.0.0-alpha.10 → 3.0.0-alpha.12

package/src/api/build.ts

@@ -1,7 +1,8 @@
 import { spawn } from 'node:child_process'
 import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { tmpdir } from 'node:os'
+import { tmpdir, homedir } from 'node:os'
 import { parse, join, resolve } from 'node:path'
 
 import * as colors from 'colorette'
@@ -143,11 +144,115 @@ class Builder {
       .setPackage()
       .setFeatures()
       .setTarget()
+      .pickCrossToolchain()
       .setEnvs()
       .setBypassArgs()
       .exec()
   }
 
+  private pickCrossToolchain() {
+    if (!this.options.useNapiCross) {
+      return this
+    }
+    if (this.options.useCross) {
+      debug.warn(
+        'You are trying to use both `--cross` and `--use-napi-cross` options, `--use-cross` will be ignored.',
+      )
+    }
+
+    if (this.options.crossCompile) {
+      debug.warn(
+        'You are trying to use both `--cross-compile` and `--use-napi-cross` options, `--cross-compile` will be ignored.',
+      )
+    }
+
+    try {
+      const { version, download } = require('@napi-rs/cross-toolchain')
+
+      const toolchainPath = join(
+        homedir(),
+        '.napi-rs',
+        'cross-toolchain',
+        version,
+        this.target.triple,
+      )
+      mkdirSync(toolchainPath, { recursive: true })
+      if (existsSync(join(toolchainPath, 'package.json'))) {
+        debug(`Toolchain ${toolchainPath} exists, skip extracting`)
+      } else {
+        const tarArchive = download(process.arch, this.target.triple)
+        tarArchive.unpack(toolchainPath)
+      }
+      const upperCaseTarget = targetToEnvVar(this.target.triple)
+      const linkerEnv = `CARGO_TARGET_${upperCaseTarget}_LINKER`
+      this.envs[linkerEnv] = join(
+        toolchainPath,
+        'bin',
+        `${this.target.triple}-gcc`,
+      )
+      if (!process.env.TARGET_SYSROOT) {
+        this.envs[`TARGET_SYSROOT`] = join(
+          toolchainPath,
+          this.target.triple,
+          'sysroot',
+        )
+      }
+      if (!process.env.TARGET_AR) {
+        this.envs[`TARGET_AR`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-ar`,
+        )
+      }
+      if (!process.env.TARGET_RANLIB) {
+        this.envs[`TARGET_RANLIB`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-ranlib`,
+        )
+      }
+      if (!process.env.TARGET_READELF) {
+        this.envs[`TARGET_READELF`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-readelf`,
+        )
+      }
+      if (!process.env.TARGET_C_INCLUDE_PATH) {
+        this.envs[`TARGET_C_INCLUDE_PATH`] = join(
+          toolchainPath,
+          this.target.triple,
+          'sysroot',
+          'usr',
+          'include/',
+        )
+      }
+      if (!process.env.CC && !process.env.TARGET_CC) {
+        this.envs[`CC`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-gcc`,
+        )
+        this.envs[`TARGET_CC`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-gcc`,
+        )
+      }
+      if (
+        (process.env.CC === 'clang' &&
+          (process.env.TARGET_CC === 'clang' || !process.env.TARGET_CC)) ||
+        process.env.TARGET_CC === 'clang'
+      ) {
+        this.envs.C_FLAGS = `--sysroot=${this.envs.TARGET_SYSROOT}`
+      }
+    } catch (e) {
+      debug.warn('Pick cross toolchain failed', e as Error)
+      // ignore, do nothing
+    }
+    return this
+  }
+
   private exec() {
     debug(`Start building crate: ${this.crate.name}`)
     debug('  %i', `cargo ${this.args.join(' ')}`)
@@ -156,6 +261,11 @@ class Builder {
 
     const watch = this.options.watch
     const buildTask = new Promise<void>((resolve, reject) => {
+      if (this.options.useCross && this.options.crossCompile) {
+        throw new Error(
+          '`--use-cross` and `--cross-compile` can not be used together',
+        )
+      }
       const command =
         process.env.CARGO ?? (this.options.useCross ? 'cross' : 'cargo')
       const buildProcess = spawn(command, this.args, {

package/src/api/new.ts

@@ -10,6 +10,8 @@ import {
   debugFactory,
   DEFAULT_TARGETS,
   mkdirAsync,
+  readdirAsync,
+  statAsync,
   writeFileAsync,
 } from '../utils/index.js'
 import { napiEngineRequirement } from '../utils/version.js'
@@ -69,21 +71,45 @@ export async function newProject(userOptions: RawNewOptions) {
 
   const outputs = generateFiles(options)
 
-  try {
-    debug(`Try to create target directory: ${options.path}`)
-    if (!options.dryRun) {
-      await mkdirAsync(options.path, { recursive: true })
-    }
-  } catch (e) {
-    throw new Error(`Failed to create target directory: ${options.path}`, {
-      cause: e,
-    })
-  }
+  await ensurePath(options.path, options.dryRun)
 
   await dumpOutputs(outputs, options.dryRun)
   debug(`Project created at: ${options.path}`)
 }
 
+async function ensurePath(path: string, dryRun = false) {
+  const stat = await statAsync(path, {}).catch(() => undefined)
+
+  // file descriptor exists
+  if (stat) {
+    if (stat.isFile()) {
+      throw new Error(
+        `Path ${path} for creating new napi-rs project already exists and it's not a directory.`,
+      )
+    } else if (stat.isDirectory()) {
+      const files = await readdirAsync(path)
+      if (files.length) {
+        throw new Error(
+          `Path ${path} for creating new napi-rs project already exists and it's not empty.`,
+        )
+      }
+    }
+  }
+
+  if (!dryRun) {
+    try {
+      debug(`Try to create target directory: ${path}`)
+      if (!dryRun) {
+        await mkdirAsync(path, { recursive: true })
+      }
+    } catch (e) {
+      throw new Error(`Failed to create target directory: ${path}`, {
+        cause: e,
+      })
+    }
+  }
+}
+
 function generateFiles(options: NewOptions): Output[] {
   return [
     generateCargoToml,

package/src/api/templates/ci-template.ts

@@ -245,7 +245,6 @@ jobs:
             target: 'x86_64-apple-darwin'
           - host: windows-latest
             target: 'x86_64-pc-windows-msvc'
-        node: ['16', '18']
         node: ['18', '20']
     runs-on: \${{ matrix.settings.host }}
 
@@ -281,7 +280,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: ['16', '18']
         node: ['18', '20']
     runs-on: ubuntu-latest
 
@@ -317,7 +315,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: ['16', '18']
         node: ['18', '20']
     runs-on: ubuntu-latest
 
@@ -355,7 +352,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: ['16', '18']
         node: ['18', '20']
     runs-on: ubuntu-latest
 
@@ -401,7 +397,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: ['16', '18']
+        node: ['18', '20']
 
     runs-on: ubuntu-latest
 
@@ -446,7 +442,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: ['16', '18']
         node: ['18', '20']
     runs-on: ubuntu-latest
 

package/src/def/build.ts

@@ -110,6 +110,11 @@ export abstract class BaseBuildCommand extends Command {
       '[experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`',
   })
 
+  useNapiCross?: boolean = Option.Boolean('--use-napi-cross', {
+    description:
+      '[experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets',
+  })
+
   watch?: boolean = Option.Boolean('--watch,-w', {
     description:
       'watch the crate changes and build continiously with `cargo-watch` crates',
@@ -151,6 +156,7 @@ export abstract class BaseBuildCommand extends Command {
       profile: this.profile,
       crossCompile: this.crossCompile,
       useCross: this.useCross,
+      useNapiCross: this.useNapiCross,
       watch: this.watch,
       features: this.features,
       allFeatures: this.allFeatures,
@@ -251,6 +257,10 @@ export interface BuildOptions {
    * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`
    */
   useCross?: boolean
+  /**
+   * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets
+   */
+  useNapiCross?: boolean
   /**
    * watch the crate changes and build continiously with `cargo-watch` crates
    */

package/src/utils/config.ts

@@ -120,7 +120,7 @@ export async function readNapiConfig(path: string): Promise<NapiConfig> {
 
   // compatible with old config
   if (userNapiConfig?.name) {
-    napiConfig.packageName = userNapiConfig.name
+    napiConfig.binaryName = userNapiConfig.name
   }
 
   if (!targets.length) {

package/src/utils/target.ts

@@ -1,4 +1,4 @@
-import { execSync } from 'child_process'
+import { execSync } from 'node:child_process'
 
 export type Platform = NodeJS.Platform | 'wasm' | 'wasi'