@ohos-rs/oxk 0.0.1-beta.0

package/README.md

@@ -0,0 +1,31 @@
+# `@ohos-rs/oxk`
+
+> This is forked from [package-template-pnpm](https://github.com/napi-rs/package-template-pnpm).
+
+## Usage
+
+Install with npm
+
+```bash
+npm install @ohos-rs/oxk
+```
+
+### Run with cli
+
+```bash
+oxk format xxx.ets
+```
+
+### Run with code
+
+Using napi-native module format.
+
+```js
+const oxk = require('@ohos-rs/oxk')
+```
+
+Using wrapper module format.
+
+```js
+const oxk = require('@ohos-rs/oxk/format')
+```

package/bin/format.js

@@ -0,0 +1,64 @@
+const { readFileSync, writeFileSync } = require('fs')
+const { relative } = require('path')
+const { format } = require('../format.js')
+const { glob } = require('glob')
+
+async function formatFiles(files) {
+  if (files.length === 0) {
+    console.error('Error: No files specified for formatting')
+    process.exit(1)
+  }
+
+  let hasErrors = false
+  let formattedCount = 0
+  const allFiles = new Set() // Use Set to avoid duplicates
+
+  // Use glob to expand patterns
+  for (const filePattern of files) {
+    try {
+      const matchedFiles = await glob(filePattern, {
+        absolute: true,
+        ignore: ['**/node_modules/**'],
+      })
+      matchedFiles.forEach((file) => allFiles.add(file))
+    } catch (error) {
+      console.error(`Error expanding pattern "${filePattern}":`, error.message)
+      hasErrors = true
+    }
+  }
+
+  if (allFiles.size === 0) {
+    console.error('Error: No files found matching the specified patterns')
+    process.exit(1)
+  }
+
+  for (const filePath of allFiles) {
+    try {
+      const sourceText = readFileSync(filePath, 'utf-8')
+      // Use relative path for format function (it expects the original file name)
+      const relativePath = relative(process.cwd(), filePath)
+
+      const result = await format(relativePath, sourceText)
+
+      if (result.errors.length > 0) {
+        console.error(`Error formatting ${relativePath}:`)
+        result.errors.forEach((err) => console.error(`  ${err}`))
+        hasErrors = true
+      } else {
+        writeFileSync(filePath, result.code, 'utf-8')
+        console.log(`Formatted: ${relativePath}`)
+        formattedCount++
+      }
+    } catch (error) {
+      console.error(`Error processing ${filePath}:`, error.message)
+      hasErrors = true
+    }
+  }
+
+  console.log(`\nFormatted ${formattedCount} file(s)`)
+  if (hasErrors) {
+    process.exit(1)
+  }
+}
+
+module.exports = { formatFiles }

package/bin/oxk.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+const VERSION = require('../package.json').version
+
+// Import command modules
+const { formatFiles } = require('./format.js')
+
+function showHelp() {
+  console.log(`
+oxk - An ArkTS/ArkUI tool based on OXC
+
+Usage:
+  oxk <command> [options] [files...]
+
+Commands:
+  format    Format files
+  lint      Lint files (not yet supported)
+
+Options:
+  --help, -h     Show help
+  --version, -v  Show version
+
+Examples:
+  oxk format src/**/*.ets
+`)
+}
+
+function showVersion() {
+  console.log(`oxk v${VERSION}`)
+}
+
+// Main CLI handler
+async function main() {
+  const args = process.argv.slice(2)
+
+  if (args.length === 0) {
+    showHelp()
+    process.exit(0)
+  }
+
+  const command = args[0]
+
+  // Handle global options
+  if (command === '--help' || command === '-h') {
+    showHelp()
+    process.exit(0)
+  }
+
+  if (command === '--version' || command === '-v') {
+    showVersion()
+    process.exit(0)
+  }
+
+  // Handle commands by calling functions directly
+  const remainingArgs = args.slice(1)
+
+  try {
+    switch (command) {
+      case 'format':
+        await formatFiles(remainingArgs)
+        break
+
+      default:
+        console.error(`Unknown command: ${command}`)
+        console.error("Run 'oxk --help' for usage information")
+        process.exit(1)
+    }
+  } catch (error) {
+    console.error('Unexpected error:', error)
+    process.exit(1)
+  }
+}
+
+// Run the CLI
+main()

package/browser.js

@@ -0,0 +1 @@
+export * from '@ohos-rs/oxk-wasm32-wasi'

package/format.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Format the given source text according to the specified options.
+ *
+ * This is a convenience wrapper that automatically uses Prettier for external formatter callbacks.
+ * For more control, use the raw `format` function from `./index.js` directly.
+ *
+ * @param fileName - The name of the file to format
+ * @param sourceText - The source code to format
+ * @param options - Optional formatting options (compatible with Prettier options)
+ * @returns A promise that resolves to the formatted code and any errors
+ */
+export declare function format(
+  fileName: string,
+  sourceText: string,
+  options?: Record<string, any>,
+): Promise<{ code: string; errors: string[] }>
+
+// Re-export the raw format function for advanced usage
+export { format as formatRaw } from './index.js'
+export type { FormatResult } from './index.d.ts'

package/format.js

@@ -0,0 +1,135 @@
+// Convenience wrapper that automatically uses Prettier for external formatter callbacks
+const { format: napiFormat } = require("./index.js");
+
+// Lazy load Prettier
+let prettierCache;
+
+/**
+ * TODO: Plugins support
+ * - Read `plugins` field
+ * - Load plugins dynamically and parse `languages` field
+ * - Map file extensions and filenames to Prettier parsers
+ *
+ * @returns {Promise<string[]>} Array of loaded plugin's `languages` info
+ */
+async function resolvePlugins() {
+  return [];
+}
+
+// ---
+
+const TAG_TO_PARSER = {
+  // CSS
+  css: "css",
+  styled: "css",
+  // GraphQL
+  gql: "graphql",
+  graphql: "graphql",
+  // HTML
+  html: "html",
+  // Markdown
+  md: "markdown",
+  markdown: "markdown",
+};
+
+/**
+ * Format xxx-in-js code snippets
+ *
+ * @param {Object} param
+ * @param {string} param.code
+ * @param {string} param.tagName
+ * @param {any} param.options
+ * @returns {Promise<string>} Formatted code snippet
+ */
+async function formatEmbeddedCode({ code, tagName, options }) {
+  // TODO: This should be resolved in Rust side
+  const parserName = TAG_TO_PARSER[tagName];
+
+  // Unknown tag, return original code
+  if (!parserName) return code;
+
+  if (!prettierCache) {
+    prettierCache = await import("prettier");
+  }
+
+  // SAFETY: `options` is created in Rust side, so it's safe to mutate here
+  options.parser = parserName;
+  return prettierCache
+    .format(code, options)
+    .then((formatted) => formatted.trimEnd())
+    .catch(() => code);
+}
+
+/**
+ * Format non-js file
+ *
+ * @param {Object} param
+ * @param {string} param.code
+ * @param {string} param.parserName
+ * @param {string} param.fileName
+ * @param {any} param.options
+ * @returns {Promise<string>} Formatted code
+ */
+async function formatFile({ code, parserName, fileName, options }) {
+  if (!prettierCache) {
+    prettierCache = await import("prettier");
+  }
+
+  // SAFETY: `options` is created in Rust side, so it's safe to mutate here
+  // We specify `parser` to skip parser inference for performance
+  options.parser = parserName;
+  // But some plugins rely on `filepath`, so we set it too
+  options.filepath = fileName;
+  return prettierCache.format(code, options);
+}
+
+/**
+ * Format the given source text according to the specified options.
+ *
+ * This is a convenience wrapper that automatically uses Prettier for external formatter callbacks.
+ * For more control, use the raw `format` function from `./index.js` directly.
+ *
+ * @param {string} fileName - The name of the file to format
+ * @param {string} sourceText - The source code to format
+ * @param {Record<string, any>} [options] - Optional formatting options (compatible with Prettier options)
+ * @returns {Promise<{code: string, errors: string[]}>} A promise that resolves to the formatted code and any errors
+ */
+async function format(fileName, sourceText, options) {
+  if (typeof fileName !== "string")
+    throw new TypeError("`fileName` must be a string");
+  if (typeof sourceText !== "string")
+    throw new TypeError("`sourceText` must be a string");
+
+  return napiFormat(
+    fileName,
+    sourceText,
+    options ?? {},
+    resolvePlugins,
+    (options, tagName, code) => formatEmbeddedCode({ options, tagName, code }),
+    (options, parserName, fileName, code) =>
+      formatFile({ options, parserName, fileName, code }),
+  );
+}
+
+// Re-export the raw format function for advanced usage
+function formatRaw(
+  fileName,
+  sourceText,
+  options,
+  initExternalFormatterCb,
+  formatEmbeddedCb,
+  formatFileCb,
+) {
+  const { format } = require("./index.js");
+  return format(
+    fileName,
+    sourceText,
+    options,
+    initExternalFormatterCb,
+    formatEmbeddedCb,
+    formatFileCb,
+  );
+}
+
+module.exports = { format, formatRaw };
+

package/index.d.ts

@@ -0,0 +1,18 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/**
+ * Format a file with the given options.
+ *
+ * This function supports multiple file types:
+ * - JavaScript/TypeScript files (via oxc_formatter)
+ * - TOML files (via oxc_toml)
+ * - Other files (via external formatter callbacks when napi feature is enabled)
+ */
+export declare function format(filename: string, sourceText: string, options?: any | undefined | null, initExternalFormatterCb?: (numThreads: number) => Promise<string[]>, formatEmbeddedCb?: (options: Record<string, any>, tagName: string, code: string) => Promise<string>, formatFileCb?: (options: Record<string, any>, parserName: string, fileName: string, code: string) => Promise<string>): Promise<FormatResult>
+
+export interface FormatResult {
+  /** The formatted code. */
+  code: string
+  /** Parse and format errors. */
+  errors: Array<string>
+}

package/index.js

@@ -0,0 +1,575 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return 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 = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  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
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./oxk.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-android-arm64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./oxk.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-android-arm-eabi')
+        const bindingPackageVersion = require('@ohos-rs/oxk-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') {
+        try {
+        return require('./oxk.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-win32-x64-gnu')
+        const bindingPackageVersion = require('@ohos-rs/oxk-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./oxk.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-win32-x64-msvc')
+        const bindingPackageVersion = require('@ohos-rs/oxk-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./oxk.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-win32-ia32-msvc')
+        const bindingPackageVersion = require('@ohos-rs/oxk-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./oxk.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-win32-arm64-msvc')
+        const bindingPackageVersion = require('@ohos-rs/oxk-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./oxk.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@ohos-rs/oxk-darwin-universal')
+      const bindingPackageVersion = require('@ohos-rs/oxk-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./oxk.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-darwin-x64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./oxk.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-darwin-arm64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./oxk.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-freebsd-x64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./oxk.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-freebsd-arm64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./oxk.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-x64-musl')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./oxk.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-x64-gnu')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./oxk.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-arm64-musl')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./oxk.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-arm64-gnu')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./oxk.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./oxk.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./oxk.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-loong64-musl')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./oxk.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-loong64-gnu')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./oxk.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-riscv64-musl')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./oxk.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@ohos-rs/oxk-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@ohos-rs/oxk-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./oxk.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@ohos-rs/oxk-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./oxk.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-linux-s390x-gnu')
+        const bindingPackageVersion = require('@ohos-rs/oxk-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./oxk.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-openharmony-arm64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./oxk.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-openharmony-x64')
+        const bindingPackageVersion = require('@ohos-rs/oxk-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./oxk.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@ohos-rs/oxk-openharmony-arm')
+        const bindingPackageVersion = require('@ohos-rs/oxk-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./oxk.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      wasiBinding = require('@ohos-rs/oxk-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        wasiBindingError.cause = err
+        loadErrors.push(err)
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
+    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
+    error.cause = wasiBindingError
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      {
+        cause: loadErrors.reduce((err, cur) => {
+          cur.cause = err
+          return cur
+        }),
+      },
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.format = nativeBinding.format

package/package.json

@@ -0,0 +1,136 @@
+{
+  "name": "@ohos-rs/oxk",
+  "version": "0.0.1-beta.0",
+  "description": "An ArkTS/ArkUI tool based on oxc",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "browser": "browser.js",
+  "bin": {
+    "oxk": "./bin/oxk.js"
+  },
+  "repository": {
+    "url": "git+git@github.com:ohos-rs/oxc-ark.git",
+    "type": "git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "napi-rs",
+    "NAPI",
+    "N-API",
+    "Rust",
+    "node-addon",
+    "node-addon-api"
+  ],
+  "files": [
+    "index.d.ts",
+    "index.js",
+    "browser.js",
+    "format.js",
+    "format.d.ts",
+    "bin"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./format": {
+      "types": "./format.d.ts",
+      "default": "./format.js"
+    }
+  },
+  "napi": {
+    "binaryName": "oxk",
+    "targets": [
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-musl",
+      "aarch64-unknown-linux-gnu",
+      "i686-pc-windows-msvc",
+      "armv7-unknown-linux-gnueabihf",
+      "aarch64-linux-android",
+      "x86_64-unknown-freebsd",
+      "aarch64-unknown-linux-musl",
+      "aarch64-pc-windows-msvc",
+      "armv7-linux-androideabi",
+      "wasm32-wasi-preview1-threads"
+    ]
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "bench": "node --import @oxc-node/core/register benchmark/bench.ts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "format": "run-p format:prettier format:rs format:toml",
+    "format:prettier": "prettier . -w",
+    "format:toml": "taplo format",
+    "format:rs": "cargo fmt",
+    "lint": "oxlint",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "ava",
+    "version": "napi version"
+  },
+  "dependencies": {
+    "glob": "^11.0.0",
+    "prettier": "^3.7.4"
+  },
+  "devDependencies": {
+    "@emnapi/core": "^1.5.0",
+    "@emnapi/runtime": "^1.5.0",
+    "@napi-rs/cli": "^3.2.0",
+    "@napi-rs/wasm-runtime": "^1.0.4",
+    "@oxc-node/core": "^0.0.35",
+    "@tybys/wasm-util": "^0.10.0",
+    "ava": "^6.4.1",
+    "chalk": "^5.6.2",
+    "emnapi": "^1.5.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.6",
+    "npm-run-all2": "^8.0.4",
+    "oxlint": "^1.14.0",
+    "tinybench": "^6.0.0",
+    "typescript": "^5.9.2"
+  },
+  "ava": {
+    "files": [
+      "__test__/**/*.spec.ts"
+    ],
+    "extensions": {
+      "ts": "module"
+    },
+    "timeout": "2m",
+    "workerThreads": false,
+    "environmentVariables": {
+      "TS_NODE_PROJECT": "./tsconfig.json"
+    },
+    "nodeArguments": [
+      "--import",
+      "@oxc-node/core/register"
+    ]
+  },
+  "optionalDependencies": {
+    "@ohos-rs/oxk-darwin-x64": "0.0.1-beta.0",
+    "@ohos-rs/oxk-darwin-arm64": "0.0.1-beta.0",
+    "@ohos-rs/oxk-linux-x64-gnu": "0.0.1-beta.0",
+    "@ohos-rs/oxk-win32-x64-msvc": "0.0.1-beta.0",
+    "@ohos-rs/oxk-linux-x64-musl": "0.0.1-beta.0",
+    "@ohos-rs/oxk-linux-arm64-gnu": "0.0.1-beta.0",
+    "@ohos-rs/oxk-win32-ia32-msvc": "0.0.1-beta.0",
+    "@ohos-rs/oxk-linux-arm-gnueabihf": "0.0.1-beta.0",
+    "@ohos-rs/oxk-android-arm64": "0.0.1-beta.0",
+    "@ohos-rs/oxk-freebsd-x64": "0.0.1-beta.0",
+    "@ohos-rs/oxk-linux-arm64-musl": "0.0.1-beta.0",
+    "@ohos-rs/oxk-win32-arm64-msvc": "0.0.1-beta.0",
+    "@ohos-rs/oxk-android-arm-eabi": "0.0.1-beta.0",
+    "@ohos-rs/oxk-wasm32-wasi": "0.0.1-beta.0"
+  }
+}