@napi-rs/cli 3.0.0-alpha.8 → 3.0.0-alpha.80

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

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

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

@@ -1,16 +1,48 @@
 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')
+    return `${bindingHeader}
+const { createRequire } = require('node:module')
+require = createRequire(__filename)
 
-const { platform, arch } = process
+${createCommonBinding(localName, pkgName)}
+module.exports = nativeBinding
+${idents
+        .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
+        .join('\n')}
+`;
+}
+export function createEsmBinding(localName, pkgName, idents) {
+    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 */
+`;
+function createCommonBinding(localName, pkgName) {
+    function requireTuple(tuple) {
+        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
@@ -37,7 +69,11 @@ const isMuslFromFilesystem = () => {
 }
 
 const isMuslFromReport = () => {
-  const report = typeof process.report.getReport === 'function' ? process.report.getReport() : null
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
   if (!report) {
     return null
   }
@@ -61,233 +97,116 @@ 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 {
+        ${requireTuple('linux-x64-gnu')}
+      }
+    } 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 {
-        nativeBinding = require('${pkgName}-darwin-universal')
+        ${requireTuple('linux-arm-gnueabihf')}
       }
-      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 === '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')}
 `;
 }
 //# sourceMappingURL=js-binding.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"js-binding.js","sourceRoot":"","sources":["../../../src/api/templates/js-binding.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,OAAe,EACf,MAAgB;IAEhB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAkEgD,SAAS;;;yCAGzB,SAAS;;uCAEX,OAAO;;;;;;;yDAOW,SAAS;;;yCAGzB,SAAS;;uCAEX,OAAO;;;;;;;;;;;;;;6BAcjB,SAAS;;;;yCAIG,SAAS;;uCAEX,OAAO;;;;;;;;6BAQjB,SAAS;;;;yCAIG,SAAS;;uCAEX,OAAO;;;;;;;;6BAQjB,SAAS;;;;yCAIG,SAAS;;uCAEX,OAAO;;;;;;;;;;;qDAWO,SAAS;;;qCAGzB,SAAS;;mCAEX,OAAO;;;;;;yDAMe,SAAS;;;yCAGzB,SAAS;;uCAEX,OAAO;;;;;;;;6BAQjB,SAAS;;;;yCAIG,SAAS;;uCAEX,OAAO;;;;;;;;;;;;;;qDAcO,SAAS;;;qCAGzB,SAAS;;mCAEX,OAAO;;;;;;;;;;;+BAWX,SAAS;;;;2CAIG,SAAS;;yCAEX,OAAO;;;;;;;+BAOjB,SAAS;;;;2CAIG,SAAS;;yCAEX,OAAO;;;;;;;;;;+BAUjB,SAAS;;;;2CAIG,SAAS;;yCAEX,OAAO;;;;;;;+BAOjB,SAAS;;;;2CAIG,SAAS;;yCAEX,OAAO;;;;;;;;;6BASnB,SAAS;;;;yCAIG,SAAS;;uCAEX,OAAO;;;;;;;;;;;;;;;;;;;;;EAqB5C,MAAM;SACL,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,KAAK,oBAAoB,KAAK,EAAE,CAAC;SAClE,IAAI,CAAC,IAAI,CAAC;CACZ,CAAA;AACD,CAAC"}
+{"version":3,"file":"js-binding.js","sourceRoot":"","sources":["../../../src/api/templates/js-binding.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,OAAe,EACf,MAAgB;IAEhB,OAAO,GAAG,aAAa;;;;EAIvB,mBAAmB,CAAC,SAAS,EAAE,OAAO,CAAC;;EAEvC,MAAM;SACL,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,KAAK,oBAAoB,KAAK,EAAE,CAAC;SAClE,IAAI,CAAC,IAAI,CAAC;CACZ,CAAA;AACD,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,OAAe,EACf,MAAgB;IAEhB,OAAO,GAAG,aAAa;;;;;EAKvB,mBAAmB,CAAC,SAAS,EAAE,OAAO,CAAC;UAC/B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;EACzB,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;CACxD,CAAA;AACD,CAAC;AAED,MAAM,aAAa,GAAG;;;;CAIrB,CAAA;AAED,SAAS,mBAAmB,CAAC,SAAiB,EAAE,OAAe;IAC7D,SAAS,YAAY,CAAC,KAAa;QACjC,OAAO;4BACiB,SAAS,IAAI,KAAK;;;;;0BAKpB,OAAO,IAAI,KAAK;;;;CAIzC,CAAA;IACC,CAAC;IAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkED,YAAY,CAAC,eAAe,CAAC;;QAE7B,YAAY,CAAC,kBAAkB,CAAC;;;;;;QAMhC,YAAY,CAAC,gBAAgB,CAAC;;QAE9B,YAAY,CAAC,iBAAiB,CAAC;;QAE/B,YAAY,CAAC,kBAAkB,CAAC;;;;;MAKlC,YAAY,CAAC,kBAAkB,CAAC;;QAE9B,YAAY,CAAC,YAAY,CAAC;;QAE1B,YAAY,CAAC,cAAc,CAAC;;;;;;QAM5B,YAAY,CAAC,aAAa,CAAC;;QAE3B,YAAY,CAAC,eAAe,CAAC;;;;;;;UAO3B,YAAY,CAAC,gBAAgB,CAAC;;UAE9B,YAAY,CAAC,eAAe,CAAC;;;;UAI7B,YAAY,CAAC,kBAAkB,CAAC;;UAEhC,YAAY,CAAC,iBAAiB,CAAC;;;;UAI/B,YAAY,CAAC,sBAAsB,CAAC;;UAEpC,YAAY,CAAC,qBAAqB,CAAC;;;;UAInC,YAAY,CAAC,oBAAoB,CAAC;;UAElC,YAAY,CAAC,mBAAmB,CAAC;;;QAGnC,YAAY,CAAC,iBAAiB,CAAC;;QAE/B,YAAY,CAAC,iBAAiB,CAAC;;;;;;;;;;;;;iCAaN,SAAS;;;;;;;;iCAQT,OAAO;;;;;;;;;;;;;;;;;;;CAmBvC,CAAA;AACD,CAAC"}

package/dist/api/templates/lib.rs.js

@@ -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/dist/api/templates/lib.rs.js.map

@@ -1 +1 @@
-{"version":3,"file":"lib.rs.js","sourceRoot":"","sources":["../../../src/api/templates/lib.rs.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,EAAE,CAAC;;;;;;;;;CAShC,CAAA"}
+{"version":3,"file":"lib.rs.js","sourceRoot":"","sources":["../../../src/api/templates/lib.rs.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,EAAE,CAAC;;;;;;CAMhC,CAAA"}

package/dist/api/templates/load-wasi-template.d.ts

@@ -0,0 +1,2 @@
+export declare const createWasiBrowserBinding: (wasiFilename: string, initialMemory?: number, maximumMemory?: number, fs?: boolean, asyncInit?: boolean) => string;
+export declare const createWasiBinding: (wasmFileName: string, packageName: string, initialMemory?: number, maximumMemory?: number) => string;

package/dist/api/templates/load-wasi-template.js

@@ -0,0 +1,168 @@
+export const createWasiBrowserBinding = (wasiFilename, initialMemory = 4000, maximumMemory = 65536, fs = false, asyncInit = 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`
+        : '';
+    const emnapiInstantiateImport = asyncInit
+        ? `instantiateNapiModule as __emnapiInstantiateNapiModule`
+        : `instantiateNapiModuleSync as __emnapiInstantiateNapiModuleSync`;
+    const emnapiInstantiateCall = asyncInit
+        ? `await __emnapiInstantiateNapiModule`
+        : `__emnapiInstantiateNapiModuleSync`;
+    return `import {
+  createOnMessage as __wasmCreateOnMessageForFsProxy,
+  getDefaultContext as __emnapiGetDefaultContext,
+  ${emnapiInstantiateImport},
+  WASI as __WASI,
+} 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,
+} = ${emnapiInstantiateCall}(__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 }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+`;
+};
+export const createWasiBinding = (wasmFileName, packageName, 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 {
+  createOnMessage: __wasmCreateOnMessageForFsProxy,
+  getDefaultContext: __emnapiGetDefaultContext,
+  instantiateNapiModuleSync: __emnapiInstantiateNapiModuleSync,
+} = 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 }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+`;
+//# sourceMappingURL=load-wasi-template.js.map

package/dist/api/templates/load-wasi-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-wasi-template.js","sourceRoot":"","sources":["../../../src/api/templates/load-wasi-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACtC,YAAoB,EACpB,aAAa,GAAG,IAAI,EACpB,aAAa,GAAG,KAAK,EACrB,EAAE,GAAG,KAAK,EACV,SAAS,GAAG,KAAK,EACjB,EAAE;IACF,MAAM,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC,kDAAkD,CAAC,CAAC,CAAC,EAAE,CAAA;IAC7E,MAAM,YAAY,GAAG,EAAE;QACrB,CAAC,CAAC;;;;;;;;;GASH;QACC,CAAC,CAAC;;;GAGH,CAAA;IAED,MAAM,eAAe,GAAG,EAAE;QACxB,CAAC,CAAC,iFAAiF;QACnF,CAAC,CAAC,EAAE,CAAA;IAEN,MAAM,uBAAuB,GAAG,SAAS;QACvC,CAAC,CAAC,wDAAwD;QAC1D,CAAC,CAAC,gEAAgE,CAAA;IACpE,MAAM,qBAAqB,GAAG,SAAS;QACrC,CAAC,CAAC,qCAAqC;QACvC,CAAC,CAAC,mCAAmC,CAAA;IAEvC,OAAO;;;IAGL,uBAAuB;;;EAGzB,QAAQ;2BACiB,YAAY;EACrC,YAAY;;;;;aAKD,aAAa;aACb,aAAa;;;;;;;;;;MAUpB,qBAAqB;;;;;;;;EAQzB,eAAe;;;;;;;;;;;;;;;;;;;;CAoBhB,CAAA;AACD,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,YAAoB,EACpB,WAAmB,EACnB,aAAa,GAAG,IAAI,EACpB,aAAa,GAAG,KAAK,EACrB,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA6BQ,aAAa;aACb,aAAa;;;;mDAIyB,YAAY;0DACL,YAAY;;;;;;2CAM3B,WAAW;;mCAEnB,YAAY,mBAAmB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C5E,CAAA"}

package/dist/api/templates/package.json.d.ts

@@ -1,8 +1,15 @@
-export declare const createPackageJson: ({ name, binaryName, targets, license, engineRequirement, cliVersion, }: {
+import type { SupportedTestFramework } from '../../utils/config.js';
+export interface PackageMeta {
+    'dist-tags': {
+        [index: string]: string;
+    };
+}
+export declare const createPackageJson: ({ name, binaryName, targets, license, engineRequirement, cliVersion, testFramework, }: {
     name: string;
     binaryName: string;
     targets: string[];
     license: string;
     engineRequirement: string;
     cliVersion: string;
-}) => string;
+    testFramework: SupportedTestFramework;
+}) => Promise<string>;

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

@@ -1,7 +1,16 @@
-export const createPackageJson = ({ name, binaryName, targets, license, engineRequirement, cliVersion, }) => {
+import { UNIVERSAL_TARGETS } from '../../utils/target.js';
+export const createPackageJson = async ({ name, binaryName, targets, license, engineRequirement, cliVersion, testFramework, }) => {
+    const hasWasmTarget = targets.some((t) => t.includes('wasm'));
+    const universalTargets = targets.filter((t) => t in UNIVERSAL_TARGETS);
+    const unifiedtargets = universalTargets.length
+        ? targets.filter((target) => !universalTargets.some((t) => {
+            // @ts-expect-error
+            return UNIVERSAL_TARGETS[t].includes(target);
+        }))
+        : targets;
     const content = {
         name,
-        version: '1.0.0',
+        version: '0.0.0',
         license,
         engines: {
             node: engineRequirement,
@@ -9,14 +18,15 @@ export const createPackageJson = ({ name, binaryName, targets, license, engineRe
         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',
@@ -27,6 +37,18 @@ export const createPackageJson = ({ name, binaryName, targets, license, engineRe
             '@napi-rs/cli': `^${cliVersion}`,
         },
     };
+    if (testFramework === 'ava') {
+        const avaMeta = await fetch(`https://registry.npmjs.org/ava`).then((res) => res.json());
+        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());
+        const latest = wasmRuntime['dist-tags'].latest;
+        content.devDependencies['@napi-rs/wasm-runtime'] = `^${latest}`;
+    }
     return JSON.stringify(content, null, 2);
 };
 //# sourceMappingURL=package.json.js.map