@napi-rs/cli 3.0.0-alpha.3 → 3.0.0-alpha.5

package/dist/api/build.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'os';
 import { parse, join, resolve } from 'path';
 import * as colors from 'colorette';
 import { CLI_VERSION, copyFileAsync, debugFactory, DEFAULT_TYPE_DEF_HEADER, fileExists, getSystemDefaultTarget, getTargetLinker, mkdirAsync, parseMetadata, parseTriple, processTypeDef, readNapiConfig, targetToEnvVar, tryInstallCargoBinary, unlinkAsync, writeFileAsync, } from '../utils/index.js';
-import { createJsBinding } from './templates/index.js';
+import { createCjsBinding } from './templates/index.js';
 const debug = debugFactory('build');
 export async function buildProject(options) {
     debug('napi build command receive options: %O', options);
@@ -89,13 +89,15 @@ class Builder {
         debug(`Start building crate: ${this.crate.name}`);
         debug('  %i', `cargo ${this.args.join(' ')}`);
         const controller = new AbortController();
+        const watch = this.options.watch;
         const buildTask = new Promise((resolve, reject) => {
-            const buildProcess = spawn('cargo', this.args, {
+            const command = process.env.CARGO ?? (this.options.useCross ? 'cross' : 'cargo');
+            const buildProcess = spawn(command, this.args, {
                 env: {
                     ...process.env,
                     ...this.envs,
                 },
-                stdio: 'inherit',
+                stdio: watch ? ['inherit', 'inherit', 'pipe'] : 'inherit',
                 cwd: this.cwd,
                 signal: controller.signal,
             });
@@ -113,6 +115,14 @@ class Builder {
                     cause: e,
                 }));
             });
+            // watch mode only, they are piped through stderr
+            buildProcess.stderr?.on('data', (data) => {
+                const output = data.toString();
+                console.error(output);
+                if (/Finished\s(dev|release)/.test(output)) {
+                    this.postBuild().catch(() => { });
+                }
+            });
         });
         return {
             task: buildTask.then(() => this.postBuild()),
@@ -132,7 +142,7 @@ class Builder {
                 // ===>
                 // cargo watch [...] -- build --target x86_64-unknown-linux-gnu
                 // cargo watch [...] -- zigbuild --target x86_64-unknown-linux-gnu
-                this.args.push('watch', '--why', '-i', '*.{js,ts,node}', '-w', this.crateDir, '--', 'cargo');
+                this.args.push('watch', '--why', '-i', '*.{js,ts,node}', '-w', this.crateDir, '--', 'cargo', 'build');
                 set = true;
             }
         }
@@ -287,6 +297,9 @@ class Builder {
         if (this.options.targetDir) {
             this.args.push('--target-dir', this.options.targetDir);
         }
+        if (this.options.profile) {
+            this.args.push('--profile', this.options.profile);
+        }
         if (this.options.cargoOptions?.length) {
             this.args.push(...this.options.cargoOptions);
         }
@@ -321,8 +334,8 @@ class Builder {
         await this.copyArtifact();
         // only for cdylib
         if (this.cdyLibName) {
-            await this.generateTypeDef();
-            await this.writeJsBinding();
+            const idents = await this.generateTypeDef();
+            await this.writeJsBinding(idents);
         }
         return this.outputs;
     }
@@ -331,7 +344,9 @@ class Builder {
         if (!srcName || !destName) {
             return;
         }
-        const src = join(this.targetDir, this.target.triple, this.options.release ? 'release' : 'debug', srcName);
+        const profile = this.options.profile ?? (this.options.release ? 'release' : 'debug');
+        const src = join(this.targetDir, this.target.triple, profile, srcName);
+        debug(`Copy artifact from: [${src}]`);
         const dest = join(this.outputDir, destName);
         try {
             if (await fileExists(dest)) {
@@ -378,10 +393,10 @@ class Builder {
     }
     async generateTypeDef() {
         if (!(await fileExists(this.envs.TYPE_DEF_TMP_PATH))) {
-            return;
+            return [];
         }
         const dest = join(this.outputDir, this.options.dts ?? 'index.d.ts');
-        const dts = await processTypeDef(this.envs.TYPE_DEF_TMP_PATH, !this.options.noDtsHeader
+        const { dts, exports } = await processTypeDef(this.envs.TYPE_DEF_TMP_PATH, !this.options.noDtsHeader
             ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
             : '');
         try {
@@ -397,17 +412,22 @@ class Builder {
             debug.error('Failed to write type def file');
             debug.error(e);
         }
+        return exports;
     }
-    async writeJsBinding() {
-        if (!this.options.platform || this.options.noJsBinding) {
+    async writeJsBinding(idents) {
+        if (!this.options.platform ||
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+            this.options.noJsBinding ||
+            idents.length === 0) {
             return;
         }
-        const dest = join(this.outputDir, this.options.jsBinding ?? 'index.js');
-        const js = createJsBinding(this.config.binaryName, this.config.packageName);
+        const name = parse(this.options.jsBinding ?? 'index.js').name;
+        const cjs = createCjsBinding(this.config.binaryName, this.config.packageName, idents);
         try {
+            const dest = join(this.outputDir, `${name}.js`);
             debug('Writing js binding to:');
             debug('  %i', dest);
-            await writeFileAsync(dest, js, 'utf-8');
+            await writeFileAsync(dest, cjs, 'utf-8');
             this.outputs.push({
                 kind: 'js',
                 path: dest,

package/dist/api/templates/ci-template.js

@@ -94,6 +94,14 @@ jobs:
           - host: windows-latest
             target: 'aarch64-pc-windows-msvc'
             build: yarn build --platform --target aarch64-pc-windows-msvc
+          - host: ubuntu-latest
+            target: 'riscv64gc-unknown-linux-gnu'
+            setup: |
+              sudo apt-get update
+              sudo apt-get install gcc-riscv64-linux-gnu -y
+            build: |
+              yarn build --platform --target riscv64gc-unknown-linux-gnu
+              riscv64-linux-gnu-strip *.node
 
     name: stable - \${{ matrix.settings.target }} - node@18
     runs-on: \${{ matrix.settings.host }}
@@ -106,7 +114,6 @@ jobs:
         if: \${{ !matrix.settings.docker }}
         with:
           node-version: 18
-          check-latest: true
           cache: yarn
 
       - name: Install
@@ -150,7 +157,6 @@ jobs:
         if: matrix.settings.target == 'i686-pc-windows-msvc'
         with:
           node-version: 18
-          check-latest: true
           cache: yarn
           architecture: x86
 
@@ -192,9 +198,7 @@ jobs:
           usesh: true
           mem: 3000
           prepare: |
-            pkg install -y -f curl node libnghttp2
-            curl -qL https://www.npmjs.com/install.sh | sh
-            npm install --location=global --ignore-scripts yarn
+            pkg install -y -f curl node libnghttp2 npm yarn
             curl https://sh.rustup.rs -sSf --output rustup.sh
             sh rustup.sh -y --profile minimal --default-toolchain beta
             export PATH="/usr/local/cargo/bin:$PATH"
@@ -247,7 +251,6 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: \${{ matrix.node }}
-          check-latest: true
           cache: 'yarn'
 
       - name: 'Install dependencies'
@@ -283,7 +286,6 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: \${{ matrix.node }}
-          check-latest: true
           cache: 'yarn'
 
       - name: 'Install dependencies'
@@ -319,7 +321,6 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: \${{ matrix.node }}
-          check-latest: true
           cache: 'yarn'
 
       - name: 'Install dependencies'
@@ -368,7 +369,7 @@ jobs:
           yarn config set supportedArchitectures.cpu "arm64"
           yarn config set supportedArchitectures.libc "glibc"
           yarn install
-      
+
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
         with:
@@ -483,7 +484,6 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: 18
-          check-latest: true
           cache: yarn
 
       - name: 'Install dependencies'
@@ -529,7 +529,6 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: 18
-          check-latest: true
           cache: 'yarn'
 
       - name: 'Install dependencies'

package/dist/api/templates/ci.yml.js

@@ -44,9 +44,15 @@ export const createGithubActionsCIYml = (binaryName, targets) => {
         delete fullTemplate.jobs[TEST_MACOS_WINDOWS];
     }
     else {
-        const filterTarget = enableWindowsX86 ? 'macos-latest' : 'windows-latest';
+        const filterTargets = new Set();
+        if (enableWindowsX86) {
+            filterTargets.add('windows-latest');
+        }
+        if (enableMacOSUni || enableMacOSX86) {
+            filterTargets.add('macos-latest');
+        }
         fullTemplate.jobs[TEST_MACOS_WINDOWS].strategy.matrix.settings =
-            fullTemplate.jobs[TEST_MACOS_WINDOWS].strategy.matrix.settings.filter(({ host }) => host !== filterTarget);
+            fullTemplate.jobs[TEST_MACOS_WINDOWS].strategy.matrix.settings.filter(({ host }) => filterTargets.has(host));
         requiredSteps.push(TEST_MACOS_WINDOWS);
     }
     if (!enableLinuxX86Gnu) {

package/dist/api/templates/js-binding.d.ts

@@ -1 +1 @@
-export declare function createJsBinding(localName: string, pkgName: string): string;
+export declare function createCjsBinding(localName: string, pkgName: string, idents: string[]): string;

package/dist/api/templates/js-binding.js

@@ -1,124 +1,258 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-function loadNapiModule(binaryName, packageName) {
-    const { existsSync, readFileSync } = require('fs');
-    const { join } = require('path');
-    const { platform, arch } = process;
-    const candidates = [];
-    function isMusl() {
-        // For Node 10
-        if (!process.report || typeof process.report.getReport !== 'function') {
-            try {
-                const lddPath = require('child_process')
-                    .execSync('which ldd')
-                    .toString()
-                    .trim();
-                return readFileSync(lddPath, 'utf8').includes('musl');
-            }
-            catch (e) {
-                return true;
-            }
+export function createCjsBinding(localName, pkgName, idents) {
+    return `// prettier-ignore
+/* eslint-disable */
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, '${localName}.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.android-arm64.node')
+          } else {
+            nativeBinding = require('${pkgName}-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
         }
-        else {
-            // @ts-expect-error
-            const { glibcVersionRuntime } = process.report.getReport().header;
-            return !glibcVersionRuntime;
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, '${localName}.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('${pkgName}-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
         }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Android \${arch}\`)
     }
-    switch (platform) {
-        case 'android':
-            switch (arch) {
-                case 'arm64':
-                    candidates.push('android-arm64');
-                    break;
-                case 'arm':
-                    candidates.push('android-arm-eabi');
-                    break;
-            }
-            break;
-        case 'win32':
-            switch (arch) {
-                case 'x64':
-                    candidates.push('win32-x64-msvc');
-                    break;
-                case 'ia32':
-                    candidates.push('win32-ia32-msvc');
-                    break;
-                case 'arm64':
-                    candidates.push('win32-arm64-msvc');
-                    break;
-            }
-            break;
-        case 'darwin':
-            candidates.push('darwin-universal');
-            switch (arch) {
-                case 'x64':
-                    candidates.push('darwin-x64');
-                    break;
-                case 'arm64':
-                    candidates.push('darwin-arm64');
-                    break;
-            }
-            break;
-        case 'freebsd':
-            if (arch === 'x64') {
-                candidates.push('freebsd-x64');
-            }
-            break;
-        case 'linux':
-            switch (arch) {
-                case 'x64':
-                    if (isMusl()) {
-                        candidates.push('linux-x64-musl');
-                    }
-                    else {
-                        candidates.push('linux-x64-gnu');
-                    }
-                    break;
-                case 'arm64':
-                    if (isMusl()) {
-                        candidates.push('linux-arm64-musl');
-                    }
-                    else {
-                        candidates.push('linux-arm64-gnu');
-                    }
-                    break;
-                case 'arm':
-                    candidates.push('linux-arm-gnueabihf');
-                    break;
-            }
-            break;
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('${pkgName}-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('${pkgName}-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('${pkgName}-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Windows: \${arch}\`)
     }
-    let nativeBinding;
-    let loadError;
-    for (const suffix of candidates) {
-        const localPath = join(__dirname, `${binaryName}.${suffix}.node`);
-        const pkgPath = `${packageName}-${suffix}`;
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, '${localName}.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./${localName}.darwin-universal.node')
+      } else {
+        nativeBinding = require('${pkgName}-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, '${localName}.darwin-x64.node'))
         try {
-            if (existsSync(localPath)) {
-                nativeBinding = require(localPath);
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.darwin-x64.node')
+          } else {
+            nativeBinding = require('${pkgName}-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.darwin-arm64.node')
+          } else {
+            nativeBinding = require('${pkgName}-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on macOS: \${arch}\`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(\`Unsupported architecture on FreeBSD: \${arch}\`)
+    }
+    localFileExisted = existsSync(join(__dirname, '${localName}.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./${localName}.freebsd-x64.node')
+      } else {
+        nativeBinding = require('${pkgName}-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-x64-musl')
             }
-            else {
-                nativeBinding = require(pkgPath);
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-x64-gnu')
             }
+          } catch (e) {
+            loadError = e
+          }
         }
-        catch (e) {
-            loadError = e;
-            continue;
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
         }
-        loadError = null;
-        break;
-    }
-    if (!nativeBinding) {
-        if (loadError) {
-            throw loadError;
+        break
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.linux-arm-gnueabihf.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('${pkgName}-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
         }
-        throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Linux: \${arch}\`)
     }
-    return nativeBinding;
+    break
+  default:
+    throw new Error(\`Unsupported OS: \${platform}, architecture: \${arch}\`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(\`Failed to load native binding\`)
 }
-export function createJsBinding(localName, pkgName) {
-    return `${loadNapiModule.toString()}
 
-module.exports = loadNapiModule('${localName}', '${pkgName}')
+${idents
+        .map((ident) => `module.exports.${ident} = binding.${ident}`)
+        .join('\n')}
 `;
 }

package/dist/api/templates/package.json.js

@@ -1,29 +1,31 @@
 export const createPackageJson = ({ name, binaryName, targets, license, engineRequirement, cliVersion, }) => {
-    return `{
-  "name": "${name}",
-  "version": "1.0.0",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "license": "${license}",
-  "engines": {
-    "node": "${engineRequirement}"
-  },
-  "napi": {
-    "binaryName": "${binaryName}",
-    "targets": [
-      ${targets.map((t) => `"${t}"`).join(',\n      ')}
-    ]
-  },
-  "scripts": {
-    "test": "node -e \\"assert(require('.').sum(1, 2) === 3)\\"",
-    "build": "napi build --release --platform --strip",
-    "build:debug": "napi build",
-    "prepublishOnly": "napi prepublish -t npm",
-    "artifacts": "napi artifacts",
-    "version": "napi version"
-  },
-  "devDependencies": {
-    "@napi-rs/cli": "^${cliVersion}"
-  }
-}`;
+    const content = {
+        name,
+        version: '1.0.0',
+        license,
+        engines: {
+            node: engineRequirement,
+        },
+        type: 'commonjs',
+        main: 'index.js',
+        types: 'index.d.ts',
+        module: undefined,
+        exports: undefined,
+        napi: {
+            binaryName,
+            targets,
+        },
+        scripts: {
+            test: 'node -e "assert(require(\'.\').sum(1, 2) === 3)"',
+            build: 'napi build --release --platform --strip',
+            'build:debug': 'napi build',
+            prepublishOnly: 'napi prepublish -t npm',
+            artifacts: 'napi artifacts',
+            version: 'napi version',
+        },
+        devDependencies: {
+            '@napi-rs/cli': `^${cliVersion}`,
+        },
+    };
+    return JSON.stringify(content, null, 2);
 };