@napi-rs/cli 3.0.0-alpha.94 → 3.0.0-alpha.96

package/dist/utils/config.d.ts

@@ -95,6 +95,10 @@ export interface CommonPackageJsonFields {
     author?: string;
     authors?: string[];
     license?: string;
+    cpu?: string[];
+    os?: string[];
+    libc?: string[];
+    files?: string[];
     repository?: any;
     homepage?: any;
     engines?: Record<string, string>;

package/dist/utils/target.d.ts

@@ -1,4 +1,4 @@
-export type Platform = NodeJS.Platform | 'wasm' | 'wasi';
+export type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'ohos';
 export declare const UNIVERSAL_TARGETS: {
     readonly 'universal-apple-darwin': readonly ["aarch64-apple-darwin", "x86_64-apple-darwin"];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/cli",
-  "version": "3.0.0-alpha.94",
+  "version": "3.0.0-alpha.96",
   "description": "Cli tools for napi-rs",
   "author": "LongYinan <lynweklm@gmail.com>",
   "homepage": "https://github.com/napi-rs/napi-rs",
@@ -132,5 +132,5 @@
       "e2e/**/*.spec.ts"
     ]
   },
-  "gitHead": "08c364f5a76fa5f3b887b3050ffd175d33206a30"
+  "gitHead": "f2e838cf992f437a861cdd3108e32b3ab523e464"
 }

package/src/api/__tests__/create-npm-dirs.spec.ts

@@ -0,0 +1,210 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import ava, { TestFn } from 'ava'
+
+import { createNpmDirs } from '../create-npm-dirs.js'
+
+const test = ava as TestFn<{
+  tmpDir: string
+  packageJsonPath: string
+}>
+
+test.beforeEach(async (t) => {
+  // Create a unique temp directory for tests
+  const timestamp = Date.now()
+  const random = Math.random().toString(36).substring(7)
+  const tmpDir = join(
+    tmpdir(),
+    'napi-rs-test',
+    `create-npm-dirs-${timestamp}-${random}`,
+  )
+  const packageJsonPath = join(tmpDir, 'package.json')
+
+  // Create the directory
+  await mkdir(tmpDir, { recursive: true })
+
+  t.context = { tmpDir, packageJsonPath }
+})
+
+test.afterEach.always(async (t) => {
+  // Clean up any created directories
+  if (existsSync(t.context.tmpDir)) {
+    await rm(t.context.tmpDir, { recursive: true, force: true })
+  }
+})
+
+test('should omit exports fields from publishConfig in scoped packages', async (t) => {
+  const { tmpDir, packageJsonPath } = t.context
+
+  // Create a package.json with publishConfig that includes exports field
+  const packageJson = {
+    name: 'test-package',
+    version: '1.0.0',
+    publishConfig: {
+      registry: 'https://custom-registry.com',
+      access: 'public',
+      exports: {
+        '.': './dist/index.js',
+        './package.json': './package.json',
+      },
+      tag: 'beta',
+    },
+    napi: {
+      binaryName: 'test-package',
+      targets: ['x86_64-unknown-linux-gnu'],
+    },
+  }
+
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
+
+  await createNpmDirs({
+    cwd: tmpDir,
+    packageJsonPath: 'package.json',
+  })
+
+  // Check that the scoped package directory was created
+  const scopedDir = join(tmpDir, 'npm', 'linux-x64-gnu')
+  t.true(existsSync(scopedDir))
+
+  // Read the generated package.json for the scoped package
+  const scopedPackageJsonPath = join(scopedDir, 'package.json')
+  t.true(existsSync(scopedPackageJsonPath))
+
+  const scopedPackageJson = JSON.parse(
+    await readFile(scopedPackageJsonPath, 'utf-8'),
+  )
+
+  // Verify that publishConfig only contains registry and access, not exports
+  t.truthy(scopedPackageJson.publishConfig)
+  t.is(scopedPackageJson.publishConfig.registry, 'https://custom-registry.com')
+  t.is(scopedPackageJson.publishConfig.access, 'public')
+  t.is(scopedPackageJson.publishConfig.exports, undefined)
+  t.is(scopedPackageJson.publishConfig.tag, undefined)
+})
+
+test('should handle package without publishConfig', async (t) => {
+  const { tmpDir, packageJsonPath } = t.context
+
+  // Create a package.json without publishConfig
+  const packageJson = {
+    name: 'test-package-no-config',
+    version: '1.0.0',
+    napi: {
+      binaryName: 'test-package-no-config',
+      targets: ['x86_64-unknown-linux-gnu'],
+    },
+  }
+
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
+
+  await createNpmDirs({
+    cwd: tmpDir,
+    packageJsonPath: 'package.json',
+  })
+
+  // Check that the scoped package directory was created
+  const scopedDir = join(tmpDir, 'npm', 'linux-x64-gnu')
+  t.true(existsSync(scopedDir))
+
+  // Read the generated package.json for the scoped package
+  const scopedPackageJsonPath = join(scopedDir, 'package.json')
+  const scopedPackageJson = JSON.parse(
+    await readFile(scopedPackageJsonPath, 'utf-8'),
+  )
+
+  // Verify that publishConfig is not present when not in source
+  t.is(scopedPackageJson.publishConfig, undefined)
+})
+
+test('should preserve only registry and access in publishConfig', async (t) => {
+  const { tmpDir, packageJsonPath } = t.context
+
+  // Create a package.json with minimal publishConfig
+  const packageJson = {
+    name: 'test-package-minimal',
+    version: '1.0.0',
+    publishConfig: {
+      registry: 'https://npm.company.com',
+      access: 'restricted',
+    },
+    napi: {
+      binaryName: 'test-package-minimal',
+      targets: ['aarch64-apple-darwin'],
+    },
+  }
+
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
+
+  await createNpmDirs({
+    cwd: tmpDir,
+    packageJsonPath: 'package.json',
+  })
+
+  // Check that the scoped package directory was created
+  const scopedDir = join(tmpDir, 'npm', 'darwin-arm64')
+  t.true(existsSync(scopedDir))
+
+  // Read the generated package.json for the scoped package
+  const scopedPackageJsonPath = join(scopedDir, 'package.json')
+  const scopedPackageJson = JSON.parse(
+    await readFile(scopedPackageJsonPath, 'utf-8'),
+  )
+
+  // Verify that publishConfig contains exactly registry and access
+  t.truthy(scopedPackageJson.publishConfig)
+  t.is(scopedPackageJson.publishConfig.registry, 'https://npm.company.com')
+  t.is(scopedPackageJson.publishConfig.access, 'restricted')
+  t.is(Object.keys(scopedPackageJson.publishConfig).length, 2)
+})
+
+test('should handle WASM targets correctly with publishConfig', async (t) => {
+  const { tmpDir, packageJsonPath } = t.context
+
+  // Create a package.json for WASM target
+  const packageJson = {
+    name: 'test-wasm-package',
+    version: '1.0.0',
+    publishConfig: {
+      registry: 'https://wasm-registry.com',
+      access: 'public',
+      exports: './wasm.js',
+      browser: './browser.js',
+    },
+    napi: {
+      binaryName: 'test-wasm-package',
+      targets: ['wasm32-wasi-preview1-threads'],
+    },
+  }
+
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
+
+  await createNpmDirs({
+    cwd: tmpDir,
+    packageJsonPath: 'package.json',
+  })
+
+  // Check that the scoped package directory was created
+  const scopedDir = join(tmpDir, 'npm', 'wasm32-wasi')
+  t.true(existsSync(scopedDir))
+
+  // Read the generated package.json for the scoped package
+  const scopedPackageJsonPath = join(scopedDir, 'package.json')
+  const scopedPackageJson = JSON.parse(
+    await readFile(scopedPackageJsonPath, 'utf-8'),
+  )
+
+  // Verify that publishConfig is correctly filtered for WASM too
+  t.truthy(scopedPackageJson.publishConfig)
+  t.is(scopedPackageJson.publishConfig.registry, 'https://wasm-registry.com')
+  t.is(scopedPackageJson.publishConfig.access, 'public')
+  t.is(scopedPackageJson.publishConfig.exports, undefined)
+  t.is(scopedPackageJson.publishConfig.browser, undefined)
+
+  // Verify WASM-specific fields are set correctly
+  t.truthy(scopedPackageJson.main)
+  t.truthy(scopedPackageJson.browser)
+  t.truthy(scopedPackageJson.dependencies)
+})

package/src/api/build.ts

@@ -514,86 +514,15 @@ class Builder {
     }
 
     if (this.target.platform === 'android') {
-      const { ANDROID_NDK_LATEST_HOME } = process.env
-      if (!ANDROID_NDK_LATEST_HOME) {
-        debug.warn(
-          `${colors.red(
-            'ANDROID_NDK_LATEST_HOME',
-          )} environment variable is missing`,
-        )
-      }
-
-      const targetArch = this.target.arch === 'arm' ? 'armv7a' : 'aarch64'
-      const targetPlatform =
-        this.target.arch === 'arm' ? 'androideabi24' : 'android24'
-      const hostPlatform =
-        process.platform === 'darwin'
-          ? 'darwin'
-          : process.platform === 'win32'
-            ? 'windows'
-            : 'linux'
-      Object.assign(this.envs, {
-        CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-android24-clang`,
-        CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
-        TARGET_CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
-        TARGET_CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
-        TARGET_AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ar`,
-        TARGET_RANLIB: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ranlib`,
-        ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
-        PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin:${process.env.PATH}`,
-      })
+      this.setAndroidEnv()
     }
-    // END LINKER
 
     if (this.target.platform === 'wasi') {
-      const emnapi = join(
-        require.resolve('emnapi'),
-        '..',
-        'lib',
-        'wasm32-wasi-threads',
-      )
-      this.envs.EMNAPI_LINK_DIR = emnapi
-      this.envs.SETJMP_LINK_DIR = setjmpLib
-      const { WASI_SDK_PATH } = process.env
+      this.setWasiEnv()
+    }
 
-      if (WASI_SDK_PATH && existsSync(WASI_SDK_PATH)) {
-        this.envs.CARGO_TARGET_WASM32_WASI_PREVIEW1_THREADS_LINKER = join(
-          WASI_SDK_PATH,
-          'bin',
-          'wasm-ld',
-        )
-        this.envs.CARGO_TARGET_WASM32_WASIP1_LINKER = join(
-          WASI_SDK_PATH,
-          'bin',
-          'wasm-ld',
-        )
-        this.envs.CARGO_TARGET_WASM32_WASIP1_THREADS_LINKER = join(
-          WASI_SDK_PATH,
-          'bin',
-          'wasm-ld',
-        )
-        this.envs.CARGO_TARGET_WASM32_WASIP2_LINKER = join(
-          WASI_SDK_PATH,
-          'bin',
-          'wasm-ld',
-        )
-        this.setEnvIfNotExists('CC', join(WASI_SDK_PATH, 'bin', 'clang'))
-        this.setEnvIfNotExists('CXX', join(WASI_SDK_PATH, 'bin', 'clang++'))
-        this.setEnvIfNotExists('AR', join(WASI_SDK_PATH, 'bin', 'ar'))
-        this.setEnvIfNotExists('RANLIB', join(WASI_SDK_PATH, 'bin', 'ranlib'))
-        this.setEnvIfNotExists(
-          'CFLAGS',
-          `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -I${setjmpInclude}`,
-        )
-        this.setEnvIfNotExists(
-          'CXXFLAGS',
-          `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -I${setjmpInclude}`,
-        )
-        this.setEnvIfNotExists(
-          `LDFLAGS`,
-          `-fuse-ld=${WASI_SDK_PATH}/bin/wasm-ld --target=wasm32-wasi-threads`,
-        )
-      }
+    if (this.target.abi === 'ohos') {
+      this.setOpenHarmonyEnv()
     }
 
     debug('Set envs: ')
@@ -618,6 +547,141 @@ class Builder {
     })
   }
 
+  private setAndroidEnv() {
+    const { ANDROID_NDK_LATEST_HOME } = process.env
+    if (!ANDROID_NDK_LATEST_HOME) {
+      debug.warn(
+        `${colors.red(
+          'ANDROID_NDK_LATEST_HOME',
+        )} environment variable is missing`,
+      )
+    }
+
+    // skip cross compile setup if host is android
+    if (process.platform === 'android') {
+      return
+    }
+
+    const targetArch = this.target.arch === 'arm' ? 'armv7a' : 'aarch64'
+    const targetPlatform =
+      this.target.arch === 'arm' ? 'androideabi24' : 'android24'
+    const hostPlatform =
+      process.platform === 'darwin'
+        ? 'darwin'
+        : process.platform === 'win32'
+          ? 'windows'
+          : 'linux'
+    Object.assign(this.envs, {
+      CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-android24-clang`,
+      CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
+      TARGET_CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
+      TARGET_CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
+      TARGET_AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ar`,
+      TARGET_RANLIB: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ranlib`,
+      ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
+      PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin${process.platform === 'win32' ? ';' : ':'}${process.env.PATH}`,
+    })
+  }
+
+  private setWasiEnv() {
+    const emnapi = join(
+      require.resolve('emnapi'),
+      '..',
+      'lib',
+      'wasm32-wasi-threads',
+    )
+    this.envs.EMNAPI_LINK_DIR = emnapi
+    this.envs.SETJMP_LINK_DIR = setjmpLib
+    const { WASI_SDK_PATH } = process.env
+
+    if (WASI_SDK_PATH && existsSync(WASI_SDK_PATH)) {
+      this.envs.CARGO_TARGET_WASM32_WASI_PREVIEW1_THREADS_LINKER = join(
+        WASI_SDK_PATH,
+        'bin',
+        'wasm-ld',
+      )
+      this.envs.CARGO_TARGET_WASM32_WASIP1_LINKER = join(
+        WASI_SDK_PATH,
+        'bin',
+        'wasm-ld',
+      )
+      this.envs.CARGO_TARGET_WASM32_WASIP1_THREADS_LINKER = join(
+        WASI_SDK_PATH,
+        'bin',
+        'wasm-ld',
+      )
+      this.envs.CARGO_TARGET_WASM32_WASIP2_LINKER = join(
+        WASI_SDK_PATH,
+        'bin',
+        'wasm-ld',
+      )
+      this.setEnvIfNotExists('TARGET_CC', join(WASI_SDK_PATH, 'bin', 'clang'))
+      this.setEnvIfNotExists(
+        'TARGET_CXX',
+        join(WASI_SDK_PATH, 'bin', 'clang++'),
+      )
+      this.setEnvIfNotExists('TARGET_AR', join(WASI_SDK_PATH, 'bin', 'ar'))
+      this.setEnvIfNotExists(
+        'TARGET_RANLIB',
+        join(WASI_SDK_PATH, 'bin', 'ranlib'),
+      )
+      this.setEnvIfNotExists(
+        'TARGET_CFLAGS',
+        `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -I${setjmpInclude}`,
+      )
+      this.setEnvIfNotExists(
+        'TARGET_CXXFLAGS',
+        `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -I${setjmpInclude}`,
+      )
+      this.setEnvIfNotExists(
+        `TARGET_LDFLAGS`,
+        `-fuse-ld=${WASI_SDK_PATH}/bin/wasm-ld --target=wasm32-wasi-threads`,
+      )
+    }
+  }
+
+  private setOpenHarmonyEnv() {
+    const { OHOS_SDK_PATH, OHOS_SDK_NATIVE } = process.env
+    const ndkPath = OHOS_SDK_PATH
+      ? `${OHOS_SDK_NATIVE}/native`
+      : OHOS_SDK_NATIVE
+    // @ts-expect-error
+    if (!ndkPath && process.platform !== 'openharmony') {
+      debug.warn(
+        `${colors.red('OHOS_SDK_PATH')} or ${colors.red('OHOS_SDK_NATIVE')} environment variable is missing`,
+      )
+      return
+    }
+    const linkerName = `CARGO_TARGET_${this.target.triple.toUpperCase().replace(/-/g, '_')}_LINKER`
+    const ranPath = `${ndkPath}/llvm/bin/llvm-ranlib`
+    const arPath = `${ndkPath}/llvm/bin/llvm-ar`
+    const ccPath = `${ndkPath}/llvm/bin/${this.target.triple}-clang`
+    const cxxPath = `${ndkPath}/llvm/bin/${this.target.triple}-clang++`
+    const asPath = `${ndkPath}/llvm/bin/llvm-as`
+    const ldPath = `${ndkPath}/llvm/bin/ld.lld`
+    const stripPath = `${ndkPath}/llvm/bin/llvm-strip`
+    const objDumpPath = `${ndkPath}/llvm/bin/llvm-objdump`
+    const objCopyPath = `${ndkPath}/llvm/bin/llvm-objcopy`
+    const nmPath = `${ndkPath}/llvm/bin/llvm-nm`
+    const binPath = `${ndkPath}/llvm/bin`
+    const libPath = `${ndkPath}/llvm/lib`
+
+    this.setEnvIfNotExists('LIBCLANG_PATH', libPath)
+    this.setEnvIfNotExists('DEP_ATOMIC', 'clang_rt.builtins')
+    this.setEnvIfNotExists(linkerName, ccPath)
+    this.setEnvIfNotExists('TARGET_CC', ccPath)
+    this.setEnvIfNotExists('TARGET_CXX', cxxPath)
+    this.setEnvIfNotExists('TARGET_AR', arPath)
+    this.setEnvIfNotExists('TARGET_RANLIB', ranPath)
+    this.setEnvIfNotExists('TARGET_AS', asPath)
+    this.setEnvIfNotExists('TARGET_LD', ldPath)
+    this.setEnvIfNotExists('TARGET_STRIP', stripPath)
+    this.setEnvIfNotExists('TARGET_OBJDUMP', objDumpPath)
+    this.setEnvIfNotExists('TARGET_OBJCOPY', objCopyPath)
+    this.setEnvIfNotExists('TARGET_NM', nmPath)
+    this.envs.PATH = `${binPath}${process.platform === 'win32' ? ';' : ':'}${process.env.PATH}`
+  }
+
   private setFeatures() {
     const args = []
     if (this.options.allFeatures && this.options.noDefaultFeatures) {

package/src/api/create-npm-dirs.ts

@@ -13,6 +13,7 @@ import {
   pick,
   writeFileAsync as rawWriteFileAsync,
   Target,
+  type CommonPackageJsonFields,
 } from '../utils/index.js'
 
 const debug = debugFactory('create-npm-dirs')
@@ -65,7 +66,7 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
       target.arch === 'wasm32'
         ? `${binaryName}.${target.platformArchABI}.wasm`
         : `${binaryName}.${target.platformArchABI}.node`
-    const scopedPackageJson = {
+    const scopedPackageJson: CommonPackageJsonFields = {
       name: `${packageName}-${target.platformArchABI}`,
       version: packageJson.version,
       cpu: target.arch !== 'universal' ? [target.arch] : undefined,
@@ -80,22 +81,25 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
         'homepage',
         'license',
         'engines',
-        'publishConfig',
         'repository',
         'bugs',
       ),
     }
+    if (packageJson.publishConfig) {
+      scopedPackageJson.publishConfig = pick(
+        packageJson.publishConfig,
+        'registry',
+        'access',
+      )
+    }
     if (target.arch !== 'wasm32') {
-      // @ts-expect-error
       scopedPackageJson.os = [target.platform]
     } else {
       const entry = `${binaryName}.wasi.cjs`
       scopedPackageJson.main = entry
-      // @ts-expect-error
       scopedPackageJson.browser = `${binaryName}.wasi-browser.js`
-      scopedPackageJson.files.push(
+      scopedPackageJson.files?.push(
         entry,
-        // @ts-expect-error
         scopedPackageJson.browser,
         `wasi-worker.mjs`,
         `wasi-worker-browser.mjs`,
@@ -121,17 +125,14 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
       const wasmRuntime = await fetch(
         `https://registry.npmjs.org/@napi-rs/wasm-runtime`,
       ).then((res) => res.json() as Promise<PackageMeta>)
-      // @ts-expect-error
       scopedPackageJson.dependencies = {
         '@napi-rs/wasm-runtime': `^${wasmRuntime['dist-tags'].latest}`,
       }
     }
 
     if (target.abi === 'gnu') {
-      // @ts-expect-error
       scopedPackageJson.libc = ['glibc']
     } else if (target.abi === 'musl') {
-      // @ts-expect-error
       scopedPackageJson.libc = ['musl']
     }
 

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

@@ -38,17 +38,19 @@ const bindingHeader = `// prettier-ignore
 `
 
 function createCommonBinding(localName: string, pkgName: string): string {
-  function requireTuple(tuple: string) {
+  function requireTuple(tuple: string, identSize = 8) {
+    const identLow = ' '.repeat(identSize - 2)
+    const ident = ' '.repeat(identSize)
     return `try {
-        return require('./${localName}.${tuple}.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('${pkgName}-${tuple}')
-      } catch (e) {
-        loadErrors.push(e)
-      }
+${ident}return require('./${localName}.${tuple}.node')
+${identLow}} catch (e) {
+${ident}loadErrors.push(e)
+${identLow}}
+${identLow}try {
+${ident}return require('${pkgName}-${tuple}')
+${identLow}} catch (e) {
+${ident}loadErrors.push(e)
+${identLow}}
 `
   }
 
@@ -70,6 +72,8 @@ const isMusl = () => {
   return musl
 }
 
+const isOpenHarmony = process.platform === 'openharmony'
+
 const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
 
 const isMuslFromFilesystem = () => {
@@ -135,7 +139,7 @@ function requireNative() {
       loadErrors.push(new Error(\`Unsupported architecture on Windows: \${process.arch}\`))
     }
   } else if (process.platform === 'darwin') {
-    ${requireTuple('darwin-universal')}
+    ${requireTuple('darwin-universal', 6)}
     if (process.arch === 'x64') {
       ${requireTuple('darwin-x64')}
     } else if (process.arch === 'arm64') {
@@ -154,27 +158,33 @@ function requireNative() {
   } else if (process.platform === 'linux') {
     if (process.arch === 'x64') {
       if (isMusl()) {
-        ${requireTuple('linux-x64-musl')}
+        ${requireTuple('linux-x64-musl', 8)}
+      } else if (isOpenHarmony) {
+        ${requireTuple('linux-x64-ohos', 8)}
       } else {
-        ${requireTuple('linux-x64-gnu')}
+        ${requireTuple('linux-x64-gnu', 8)}
       }
     } else if (process.arch === 'arm64') {
       if (isMusl()) {
-        ${requireTuple('linux-arm64-musl')}
+        ${requireTuple('linux-arm64-musl', 8)}
+      } else if (isOpenHarmony) {
+        ${requireTuple('linux-arm64-ohos', 8)}
       } else {
-        ${requireTuple('linux-arm64-gnu')}
+        ${requireTuple('linux-arm64-gnu', 8)}
       }
     } else if (process.arch === 'arm') {
       if (isMusl()) {
-        ${requireTuple('linux-arm-musleabihf')}
+        ${requireTuple('linux-arm-musleabihf', 8)}
+      } else if (isOpenHarmony) {
+        ${requireTuple('linux-arm-ohos', 8)}
       } else {
-        ${requireTuple('linux-arm-gnueabihf')}
+        ${requireTuple('linux-arm-gnueabihf', 8)}
       }
     } else if (process.arch === 'riscv64') {
       if (isMusl()) {
-        ${requireTuple('linux-riscv64-musl')}
+        ${requireTuple('linux-riscv64-musl', 8)}
       } else {
-        ${requireTuple('linux-riscv64-gnu')}
+        ${requireTuple('linux-riscv64-gnu', 8)}
       }
     } else if (process.arch === 'ppc64') {
       ${requireTuple('linux-ppc64-gnu')}

package/src/utils/config.ts

@@ -115,6 +115,10 @@ export interface CommonPackageJsonFields {
   author?: string
   authors?: string[]
   license?: string
+  cpu?: string[]
+  os?: string[]
+  libc?: string[]
+  files?: string[]
   repository?: any
   homepage?: any
   engines?: Record<string, string>

package/src/utils/target.ts

@@ -1,6 +1,6 @@
 import { execSync } from 'node:child_process'
 
-export type Platform = NodeJS.Platform | 'wasm' | 'wasi'
+export type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'ohos'
 
 export const UNIVERSAL_TARGETS = {
   'universal-apple-darwin': ['aarch64-apple-darwin', 'x86_64-apple-darwin'],