@napi-rs/cli 3.0.0-alpha.7 → 3.0.0-alpha.71

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

@@ -3,18 +3,57 @@ export function createCjsBinding(
   pkgName: string,
   idents: string[],
 ): string {
-  return `// prettier-ignore
+  return `${bindingHeader}
+const { createRequire } = require('node:module')
+require = createRequire(__filename)
+
+${createCommonBinding(localName, pkgName)}
+${idents
+  .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
+  .join('\n')}
+`
+}
+
+export function createEsmBinding(
+  localName: string,
+  pkgName: string,
+  idents: string[],
+): string {
+  return `${bindingHeader}
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+${createCommonBinding(localName, pkgName)}
+const { ${idents.join(', ')} } = nativeBinding
+${idents.map((ident) => `export { ${ident} }`).join('\n')}
+`
+}
+
+const bindingHeader = `// prettier-ignore
 /* eslint-disable */
+// @ts-nocheck
 /* auto-generated by NAPI-RS */
+`
 
-const { existsSync, readFileSync } = require('fs')
-const { join } = require('path')
-
-const { platform, arch } = process
+function createCommonBinding(localName: string, pkgName: string): string {
+  function requireTuple(tuple: string) {
+    return `try {
+        return require('./${localName}.${tuple}.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('${pkgName}-${tuple}')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+`
+  }
 
+  return `const { readFileSync } = require('node:fs')
 let nativeBinding = null
-let localFileExisted = false
-let loadError = null
+const loadErrors = []
 
 const isMusl = () => {
   let musl = false
@@ -65,232 +104,115 @@ const isMuslFromChildProcess = () => {
   }
 }
 
-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}\`)
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err);
     }
-    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}\`)
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      ${requireTuple('android-arm64')}
+    } else if (process.arch === 'arm') {
+      ${requireTuple('android-arm-eabi')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on Android \${process.arch}\`))
     }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, '${localName}.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./${localName}.darwin-universal.node')
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      ${requireTuple('win32-x64-msvc')}
+    } else if (process.arch === 'ia32') {
+      ${requireTuple('win32-ia32-msvc')}
+    } else if (process.arch === 'arm64') {
+      ${requireTuple('win32-arm64-msvc')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on Windows: \${process.arch}\`))
+    }
+  } else if (process.platform === 'darwin') {
+    ${requireTuple('darwin-universal')}
+    if (process.arch === 'x64') {
+      ${requireTuple('darwin-x64')}
+    } else if (process.arch === 'arm64') {
+      ${requireTuple('darwin-arm64')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on macOS: \${process.arch}\`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      ${requireTuple('freebsd-x64')}
+    } else if (process.arch === 'arm64') {
+      ${requireTuple('freebsd-arm64')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on FreeBSD: \${process.arch}\`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        ${requireTuple('linux-x64-musl')}
       } else {
-        nativeBinding = require('${pkgName}-darwin-universal')
+        ${requireTuple('linux-x64-gnu')}
       }
-      break
-    } 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}\`)
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        ${requireTuple('linux-arm64-musl')}
+      } else {
+        ${requireTuple('linux-arm64-gnu')}
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        ${requireTuple('linux-arm-musleabihf')}
+      } else {
+        ${requireTuple('linux-arm-gnueabihf')}
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        ${requireTuple('linux-riscv64-musl')}
+      } else {
+        ${requireTuple('linux-riscv64-gnu')}
+      }
+    } else if (process.arch === 'ppc64') {
+      ${requireTuple('linux-ppc64-gnu')}
+    } else if (process.arch === 's390x') {
+      ${requireTuple('linux-s390x-gnu')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on Linux: \${process.arch}\`))
     }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(\`Unsupported architecture on FreeBSD: \${arch}\`)
+  } else {
+    loadErrors.push(new Error(\`Unsupported OS: \${process.platform}, architecture: \${process.arch}\`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./${localName}.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
     }
-    localFileExisted = existsSync(join(__dirname, '${localName}.freebsd-x64.node'))
+  }
+  if (!nativeBinding) {
     try {
-      if (localFileExisted) {
-        nativeBinding = require('./${localName}.freebsd-x64.node')
-      } else {
-        nativeBinding = require('${pkgName}-freebsd-x64')
+      nativeBinding = require('${pkgName}-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
       }
-    } 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')
-            }
-          } 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
-      default:
-        throw new Error(\`Unsupported architecture on Linux: \${arch}\`)
     }
-    break
-  default:
-    throw new Error(\`Unsupported OS: \${platform}, architecture: \${arch}\`)
+  }
 }
 
 if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
+  if (loadErrors.length > 0) {
+    // TODO Link to documentation with potential fixes
+    //  - The package owner could build/publish bindings for this arch
+    //  - The user may need to bundle the correct files
+    //  - The user may need to re-install node_modules to get new packages
+    throw new Error('Failed to load native binding', { cause: loadErrors })
   }
   throw new Error(\`Failed to load native binding\`)
 }
-
-${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/load-wasi-template.ts

@@ -0,0 +1,180 @@
+export const createWasiBrowserBinding = (
+  wasiFilename: string,
+  wasiRegisterFunctions: string[],
+  initialMemory = 4000,
+  maximumMemory = 65536,
+  fs = false,
+) => {
+  const fsImport = fs ? `import { memfs } from '@napi-rs/wasm-runtime/fs'` : ''
+  const wasiCreation = fs
+    ? `
+export const { fs: __fs, vol: __volume } = memfs()
+
+const __wasi = new __WASI({
+  version: 'preview1',
+  fs: __fs,
+  preopens: {
+    '/': '/',
+  },
+})`
+    : `
+const __wasi = new __WASI({
+  version: 'preview1',
+})`
+
+  const workerFsHandler = fs
+    ? `    worker.addEventListener('message', __wasmCreateOnMessageForFsProxy(__fs))\n`
+    : ''
+
+  return `import {
+  instantiateNapiModuleSync as __emnapiInstantiateNapiModuleSync,
+  getDefaultContext as __emnapiGetDefaultContext,
+  WASI as __WASI,
+  createOnMessage as __wasmCreateOnMessageForFsProxy,
+} from '@napi-rs/wasm-runtime'
+${fsImport}
+import __wasmUrl from './${wasiFilename}.wasm?url'
+${wasiCreation}
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: ${initialMemory},
+  maximum: ${maximumMemory},
+  shared: true,
+})
+
+const __wasmFile = await fetch(__wasmUrl).then((res) => res.arrayBuffer())
+
+const {
+  instance: __napiInstance,
+  module: __wasiModule,
+  napiModule: __napiModule,
+} = __emnapiInstantiateNapiModuleSync(__wasmFile, {
+  context: __emnapiContext,
+  asyncWorkPoolSize: 4,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {
+      type: 'module',
+    })
+${workerFsHandler}
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    __napi_rs_initialize_modules(instance)
+  },
+})
+
+function __napi_rs_initialize_modules(__napiInstance) {
+${wasiRegisterFunctions
+  .map((name) => `  __napiInstance.exports['${name}']?.()`)
+  .join('\n')}
+}
+`
+}
+
+export const createWasiBinding = (
+  wasmFileName: string,
+  packageName: string,
+  wasiRegisterFunctions: string[],
+  initialMemory = 4000,
+  maximumMemory = 65536,
+) => `/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const __nodeFs = require('node:fs')
+const __nodePath = require('node:path')
+const { WASI: __nodeWASI } = require('node:wasi')
+const { Worker } = require('node:worker_threads')
+
+const {
+  instantiateNapiModuleSync: __emnapiInstantiateNapiModuleSync,
+  getDefaultContext: __emnapiGetDefaultContext,
+  createOnMessage: __wasmCreateOnMessageForFsProxy,
+} = require('@napi-rs/wasm-runtime')
+
+const __rootDir = __nodePath.parse(process.cwd()).root
+
+const __wasi = new __nodeWASI({
+  version: 'preview1',
+  env: process.env,
+  preopens: {
+    [__rootDir]: __rootDir,
+  }
+})
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: ${initialMemory},
+  maximum: ${maximumMemory},
+  shared: true,
+})
+
+let __wasmFilePath = __nodePath.join(__dirname, '${wasmFileName}.wasm')
+const __wasmDebugFilePath = __nodePath.join(__dirname, '${wasmFileName}.debug.wasm')
+
+if (__nodeFs.existsSync(__wasmDebugFilePath)) {
+  __wasmFilePath = __wasmDebugFilePath
+} else if (!__nodeFs.existsSync(__wasmFilePath)) {
+  try {
+    __wasmFilePath = __nodePath.resolve('${packageName}-wasm32-wasi')
+  } catch {
+    throw new Error('Cannot find ${wasmFileName}.wasm file, and ${packageName}-wasm32-wasi package is not installed.')
+  }
+}
+
+const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = __emnapiInstantiateNapiModuleSync(__nodeFs.readFileSync(__wasmFilePath), {
+  context: __emnapiContext,
+  asyncWorkPoolSize: (function() {
+    const threadsSizeFromEnv = Number(process.env.NAPI_RS_ASYNC_WORK_POOL_SIZE ?? process.env.UV_THREADPOOL_SIZE)
+    // NaN > 0 is false
+    if (threadsSizeFromEnv > 0) {
+      return threadsSizeFromEnv
+    } else {
+      return 4
+    }
+  })(),
+  reuseWorker: true,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(__nodePath.join(__dirname, 'wasi-worker.mjs'), {
+      env: process.env,
+    })
+    worker.onmessage = ({ data }) => {
+      __wasmCreateOnMessageForFsProxy(__nodeFs)(data)
+    }
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    __napi_rs_initialize_modules(instance)
+  }
+})
+
+function __napi_rs_initialize_modules(__napiInstance) {
+${wasiRegisterFunctions
+  .map((name) => `  __napiInstance.exports['${name}']?.()`)
+  .join('\n')}
+}
+`

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

@@ -1,12 +1,21 @@
-import { CommonPackageJsonFields } from '../../utils/config.js'
+import type {
+  CommonPackageJsonFields,
+  SupportedTestFramework,
+} from '../../utils/config.js'
+import { UNIVERSAL_TARGETS } from '../../utils/target.js'
 
-export const createPackageJson = ({
+export interface PackageMeta {
+  'dist-tags': { [index: string]: string }
+}
+
+export const createPackageJson = async ({
   name,
   binaryName,
   targets,
   license,
   engineRequirement,
   cliVersion,
+  testFramework,
 }: {
   name: string
   binaryName: string
@@ -14,10 +23,24 @@ export const createPackageJson = ({
   license: string
   engineRequirement: string
   cliVersion: string
+  testFramework: SupportedTestFramework
 }) => {
+  const hasWasmTarget = targets.some((t) => t.includes('wasm'))
+  const universalTargets = targets.filter(
+    (t) => t in UNIVERSAL_TARGETS,
+  ) as (keyof typeof UNIVERSAL_TARGETS)[]
+  const unifiedtargets = universalTargets.length
+    ? targets.filter(
+        (target) =>
+          !universalTargets.some((t) => {
+            // @ts-expect-error
+            return UNIVERSAL_TARGETS[t].includes(target)
+          }),
+      )
+    : targets
   const content: CommonPackageJsonFields = {
     name,
-    version: '1.0.0',
+    version: '0.0.0',
     license,
     engines: {
       node: engineRequirement,
@@ -25,14 +48,15 @@ export const createPackageJson = ({
     type: 'commonjs',
     main: 'index.js',
     types: 'index.d.ts',
+    browser: 'browser.js',
     module: undefined,
     exports: undefined,
     napi: {
       binaryName,
-      targets,
+      targets: unifiedtargets,
     },
     scripts: {
-      test: 'node -e "assert(require(\'.\').sum(1, 2) === 3)"',
+      test: testFramework,
       build: 'napi build --release --platform --strip',
       'build:debug': 'napi build',
       prepublishOnly: 'napi prepublish -t npm',
@@ -44,5 +68,23 @@ export const createPackageJson = ({
     },
   }
 
+  if (testFramework === 'ava') {
+    const avaMeta = await fetch(`https://registry.npmjs.org/ava`).then(
+      (res) => res.json() as Promise<PackageMeta>,
+    )
+    content.devDependencies!['ava'] = `^${avaMeta['dist-tags'].latest}`
+    content.ava = {
+      timeout: '1m',
+    }
+  }
+
+  if (hasWasmTarget) {
+    const wasmRuntime = await fetch(
+      `https://registry.npmjs.org/@napi-rs/wasm-runtime`,
+    ).then((res) => res.json() as Promise<PackageMeta>)
+    const latest = wasmRuntime['dist-tags'].latest
+    content.devDependencies!['@napi-rs/wasm-runtime'] = `^${latest}`
+  }
+
   return JSON.stringify(content, null, 2)
 }