@napi-rs/cli 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/api/templates/js-binding.ts

@@ -1,130 +1,325 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
+export function createCjsBinding(
+  localName: string,
+  pkgName: string,
+  idents: string[],
+): string {
+  return `// prettier-ignore
+/* eslint-disable */
+/* auto-generated by NAPI-RS */
 
-function loadNapiModule(binaryName: string, packageName: string) {
-  const { existsSync, readFileSync } = require('fs')
-  const { join } = require('path')
-  const { platform, arch } = process
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
 
-  const candidates: string[] = []
+const { platform, arch } = process
 
-  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 {
-      // @ts-expect-error
-      const { glibcVersionRuntime } = process.report.getReport().header
-      return !glibcVersionRuntime
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
     }
   }
+  return musl
+}
 
-  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')
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  const report = typeof process.report.getReport === 'function' ? process.report.getReport() : null
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+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
+        }
+        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}\`)
+    }
+    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 {
-            candidates.push('linux-x64-gnu')
+            nativeBinding = require('${pkgName}-win32-x64-msvc')
           }
-          break
-        case 'arm64':
-          if (isMusl()) {
-            candidates.push('linux-arm64-musl')
+        } 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 {
-            candidates.push('linux-arm64-gnu')
+            nativeBinding = require('${pkgName}-win32-ia32-msvc')
           }
-          break
-        case 'arm':
-          candidates.push('linux-arm-gnueabihf')
-          break
+        } 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}\`)
+    }
+    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
-  }
-
-  let nativeBinding: any
-  let loadError: any
-
-  for (const suffix of candidates) {
-    const localPath = join(__dirname, `${binaryName}.${suffix}.node`)
-    const pkgPath = `${packageName}-${suffix}`
-
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, '${localName}.darwin-x64.node'))
+        try {
+          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 (existsSync(localPath)) {
-        nativeBinding = require(localPath)
+      if (localFileExisted) {
+        nativeBinding = require('./${localName}.freebsd-x64.node')
       } else {
-        nativeBinding = require(pkgPath)
+        nativeBinding = require('${pkgName}-freebsd-x64')
       }
     } catch (e) {
       loadError = e
-      continue
     }
-
-    loadError = null
     break
-  }
-
-  if (!nativeBinding) {
-    if (loadError) {
-      throw loadError
+  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')
+            }
+          } 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
+          }
+        }
+        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
+          }
+        }
+        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
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Linux: \${arch}\`)
     }
+    break
+  default:
+    throw new Error(\`Unsupported OS: \${platform}, architecture: \${arch}\`)
+}
 
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
   }
-
-  return nativeBinding
+  throw new Error(\`Failed to load native binding\`)
 }
 
-export function createJsBinding(localName: string, pkgName: string): string {
-  return `${loadNapiModule.toString()}
-
-module.exports = loadNapiModule('${localName}', '${pkgName}')
+${idents
+  .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
+  .join('\n')}
 `
 }

package/src/api/templates/lib.rs.ts

@@ -1,7 +1,4 @@
-export const createLibRs = () => `#![deny(clippy::all)]
-
-#[macro_use]
-extern crate napi_derive;
+export const createLibRs = () => `use napi_derive::napi;
 
 #[napi]
 pub fn sum(a: i32, b: i32) -> i32 {

package/src/api/templates/package.json.ts

@@ -1,3 +1,5 @@
+import { CommonPackageJsonFields } from '../../utils/config.js'
+
 export const createPackageJson = ({
   name,
   binaryName,
@@ -13,32 +15,34 @@ export const createPackageJson = ({
   engineRequirement: string
   cliVersion: string
 }) => {
-  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": "yarn build:debug --platform && 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",
-    "universal": "napi universal",
-    "version": "napi version"
-  },
-  "devDependencies": {
-    "@napi-rs/cli": "^${cliVersion}"
+  const content: CommonPackageJsonFields = {
+    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)
 }

package/src/api/universalize.ts

@@ -27,7 +27,10 @@ export async function universalizeBinaries(userOptions: UniversalizeOptions) {
 
   const packageJsonPath = join(options.cwd, options.packageJsonPath)
 
-  const config = await readNapiConfig(packageJsonPath)
+  const config = await readNapiConfig(
+    packageJsonPath,
+    options.configPath ? resolve(options.cwd, options.configPath) : undefined,
+  )
 
   const target = config.targets.find(
     (t) => t.platform === process.platform && t.arch === 'universal',

package/src/api/version.ts

@@ -13,7 +13,10 @@ export async function version(userOptions: VersionOptions) {
   const options = applyDefaultVersionOptions(userOptions)
   const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
 
-  const config = await readNapiConfig(packageJsonPath)
+  const config = await readNapiConfig(
+    packageJsonPath,
+    options.configPath ? resolve(options.cwd, options.configPath) : undefined,
+  )
 
   for (const target of config.targets) {
     const pkgDir = resolve(options.cwd, options.npmDir, target.platformArchABI)

package/src/api/wasi-worker-template.ts

@@ -0,0 +1,52 @@
+export const WASI_WORKER_TEMPLATE = `import fs from "node:fs";
+import { createRequire } from "node:module";
+import { parentPort, Worker } from "node:worker_threads";
+
+import { instantiateNapiModuleSync, MessageHandler } from "@emnapi/core";
+import { WASI } from "@tybys/wasm-util";
+
+const require = createRequire(import.meta.url);
+
+if (parentPort) {
+  parentPort.on("message", (data) => {
+    globalThis.onmessage({ data });
+  });
+}
+
+Object.assign(globalThis, {
+  self: globalThis,
+  require,
+  Worker,
+  importScripts: function (f) {
+    ;(0, eval)(fs.readFileSync(f, "utf8") + "//# sourceURL=" + f);
+  },
+  postMessage: function (msg) {
+    if (parentPort) {
+      parentPort.postMessage(msg);
+    }
+  },
+});
+
+const handler = new MessageHandler({
+  onLoad({ wasmModule, wasmMemory }) {
+    const wasi = new WASI({ fs });
+
+    return instantiateNapiModuleSync(wasmModule, {
+      childThread: true,
+      wasi,
+      overwriteImports(importObject) {
+        importObject.env = {
+          ...importObject.env,
+          ...importObject.napi,
+          ...importObject.emnapi,
+          memory: wasmMemory
+        };
+      },
+    });
+  },
+});
+
+globalThis.onmessage = function (e) {
+  handler.handle(e);
+};
+`

package/src/commands/new.ts

@@ -94,10 +94,6 @@ export class NewCommand extends BaseNewCommand {
   }
 
   private async fetchTargets(): Promise<TargetTriple[]> {
-    if (this.enableDefaultTargets) {
-      return DEFAULT_TARGETS.concat()
-    }
-
     if (this.enableAllTargets) {
       return AVAILABLE_TARGETS.concat()
     }
@@ -107,7 +103,7 @@ export class NewCommand extends BaseNewCommand {
       type: 'checkbox',
       loop: false,
       message: 'Choose target(s) your crate will be compiled to',
-      default: DEFAULT_TARGETS,
+      default: this.enableDefaultTargets ? DEFAULT_TARGETS : [],
       choices: AVAILABLE_TARGETS,
     })
 

package/src/def/artifacts.ts

@@ -15,11 +15,15 @@ export abstract class BaseArtifactsCommand extends Command {
       'The working directory of where napi command will be executed in, all other paths options are relative to this path',
   })
 
+  configPath?: string = Option.String('--config-path,-c', {
+    description: 'Path to `napi` config json file',
+  })
+
   packageJsonPath = Option.String('--package-json-path', 'package.json', {
     description: 'Path to `package.json`',
   })
 
-  outputDir = Option.String('--output-dir,-o', './', {
+  outputDir = Option.String('--output-dir,-o', './artifacts', {
     description:
       'Path to the folder where all built `.node` files put, same as `--output-dir` of build command',
   })
@@ -31,6 +35,7 @@ export abstract class BaseArtifactsCommand extends Command {
   getOptions() {
     return {
       cwd: this.cwd,
+      configPath: this.configPath,
       packageJsonPath: this.packageJsonPath,
       outputDir: this.outputDir,
       npmDir: this.npmDir,
@@ -48,6 +53,10 @@ export interface ArtifactsOptions {
    * @default process.cwd()
    */
   cwd?: string
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string
   /**
    * Path to `package.json`
    *
@@ -57,7 +66,7 @@ export interface ArtifactsOptions {
   /**
    * Path to the folder where all built `.node` files put, same as `--output-dir` of build command
    *
-   * @default './'
+   * @default './artifacts'
    */
   outputDir?: string
   /**
@@ -72,7 +81,7 @@ export function applyDefaultArtifactsOptions(options: ArtifactsOptions) {
   return {
     cwd: process.cwd(),
     packageJsonPath: 'package.json',
-    outputDir: './',
+    outputDir: './artifacts',
     npmDir: 'npm',
     ...options,
   }