@napi-rs/cli 3.1.2 → 3.1.3

package/dist/index.d.ts

@@ -1,11 +1,517 @@
-import { collectArtifacts } from './api/artifacts.js';
-import { buildProject } from './api/build.js';
-import { createNpmDirs } from './api/create-npm-dirs.js';
-import { newProject } from './api/new.js';
-import { prePublish } from './api/pre-publish.js';
-import { renameProject } from './api/rename.js';
-import { universalizeBinaries } from './api/universalize.js';
-import { version } from './api/version.js';
+import { Command } from "clipanion";
+
+//#region src/def/artifacts.d.ts
+
+/**
+ * Copy artifacts from Github Actions into npm packages and ready to publish
+ */
+interface ArtifactsOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string;
+  /**
+   * Path to the folder where all built `.node` files put, same as `--output-dir` of build command
+   *
+   * @default './artifacts'
+   */
+  outputDir?: string;
+  /**
+   * Path to the folder where the npm packages put
+   *
+   * @default 'npm'
+   */
+  npmDir?: string;
+  /**
+   * Path to the build output dir, only needed when targets contains `wasm32-wasi-*`
+   */
+  buildOutputDir?: string;
+}
+//#endregion
+//#region src/api/artifacts.d.ts
+declare function collectArtifacts(userOptions: ArtifactsOptions): Promise<void>;
+//#endregion
+//#region src/def/build.d.ts
+
+/**
+ * Build the NAPI-RS project
+ */
+interface BuildOptions {
+  /**
+   * Build for the target triple, bypassed to `cargo build --target`
+   */
+  target?: string;
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   */
+  cwd?: string;
+  /**
+   * Path to `Cargo.toml`
+   */
+  manifestPath?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   */
+  packageJsonPath?: string;
+  /**
+   * Directory for all crate generated artifacts, see `cargo build --target-dir`
+   */
+  targetDir?: string;
+  /**
+   * Path to where all the built files would be put. Default to the crate folder
+   */
+  outputDir?: string;
+  /**
+   * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`
+   */
+  platform?: boolean;
+  /**
+   * Package name in generated js binding file. Only works with `--platform` flag
+   */
+  jsPackageName?: string;
+  /**
+   * Whether generate const enum for typescript bindings
+   */
+  constEnum?: boolean;
+  /**
+   * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.
+   */
+  jsBinding?: string;
+  /**
+   * Whether to disable the generation JS binding file. Only works with `--platform` flag.
+   */
+  noJsBinding?: boolean;
+  /**
+   * Path and filename of generated type def file. Relative to `--output-dir`
+   */
+  dts?: string;
+  /**
+   * Custom file header for generated type def file. Only works when `typedef` feature enabled.
+   */
+  dtsHeader?: string;
+  /**
+   * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.
+   */
+  noDtsHeader?: boolean;
+  /**
+   * Whether to enable the dts cache, default to true
+   *
+   * @default true
+   */
+  dtsCache?: boolean;
+  /**
+   * Whether to emit an ESM JS binding file instead of CJS format. Only works with `--platform` flag.
+   */
+  esm?: boolean;
+  /**
+   * Whether strip the library to achieve the minimum file size
+   */
+  strip?: boolean;
+  /**
+   * Build in release mode
+   */
+  release?: boolean;
+  /**
+   * Verbosely log build command trace
+   */
+  verbose?: boolean;
+  /**
+   * Build only the specified binary
+   */
+  bin?: string;
+  /**
+   * Build the specified library or the one at cwd
+   */
+  package?: string;
+  /**
+   * Build artifacts with the specified profile
+   */
+  profile?: string;
+  /**
+   * [experimental] cross-compile for the specified target with `cargo-xwin` on windows and `cargo-zigbuild` on other platform
+   */
+  crossCompile?: boolean;
+  /**
+   * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`
+   */
+  useCross?: boolean;
+  /**
+   * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets.
+   */
+  useNapiCross?: boolean;
+  /**
+   * watch the crate changes and build continuously with `cargo-watch` crates
+   */
+  watch?: boolean;
+  /**
+   * Space-separated list of features to activate
+   */
+  features?: string[];
+  /**
+   * Activate all available features
+   */
+  allFeatures?: boolean;
+  /**
+   * Do not activate the `default` feature
+   */
+  noDefaultFeatures?: boolean;
+}
+//#endregion
+//#region src/api/build.d.ts
+type OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';
+type Output = {
+  kind: OutputKind;
+  path: string;
+};
+type BuildOptions$1 = BuildOptions & {
+  cargoOptions?: string[];
+};
+declare function buildProject(rawOptions: BuildOptions$1): Promise<{
+  task: Promise<Output[]>;
+  abort: () => void;
+}>;
+//#endregion
+//#region src/def/create-npm-dirs.d.ts
+/**
+ * Create npm package dirs for different platforms
+ */
+interface CreateNpmDirsOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string;
+  /**
+   * Path to the folder where the npm packages put
+   *
+   * @default 'npm'
+   */
+  npmDir?: string;
+  /**
+   * Dry run without touching file system
+   *
+   * @default false
+   */
+  dryRun?: boolean;
+}
+//#endregion
+//#region src/api/create-npm-dirs.d.ts
+declare function createNpmDirs(userOptions: CreateNpmDirsOptions): Promise<void>;
+//#endregion
+//#region src/def/new.d.ts
+/**
+ * Create a new project with pre-configured boilerplate
+ */
+interface NewOptions {
+  /**
+   * The path where the NAPI-RS project will be created.
+   */
+  path?: string;
+  /**
+   * The name of the project, default to the name of the directory if not provided
+   */
+  name?: string;
+  /**
+   * The minimum Node-API version to support
+   *
+   * @default 4
+   */
+  minNodeApiVersion?: number;
+  /**
+   * The package manager to use. Only support yarn 4.x for now.
+   *
+   * @default 'yarn'
+   */
+  packageManager?: string;
+  /**
+   * License for open-sourced project
+   *
+   * @default 'MIT'
+   */
+  license?: string;
+  /**
+   * All targets the crate will be compiled for.
+   *
+   * @default []
+   */
+  targets?: string[];
+  /**
+   * Whether enable default targets
+   *
+   * @default true
+   */
+  enableDefaultTargets?: boolean;
+  /**
+   * Whether enable all targets
+   *
+   * @default false
+   */
+  enableAllTargets?: boolean;
+  /**
+   * Whether enable the `type-def` feature for typescript definitions auto-generation
+   *
+   * @default true
+   */
+  enableTypeDef?: boolean;
+  /**
+   * Whether generate preconfigured GitHub Actions workflow
+   *
+   * @default true
+   */
+  enableGithubActions?: boolean;
+  /**
+   * The JavaScript test framework to use, only support `ava` for now
+   *
+   * @default 'ava'
+   */
+  testFramework?: string;
+  /**
+   * Whether to run the command in dry-run mode
+   *
+   * @default false
+   */
+  dryRun?: boolean;
+}
+//#endregion
+//#region src/api/new.d.ts
+declare function newProject(userOptions: NewOptions): Promise<void>;
+//#endregion
+//#region src/def/pre-publish.d.ts
+/**
+ * Update package.json and copy addons into per platform packages
+ */
+interface PrePublishOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string;
+  /**
+   * Path to the folder where the npm packages put
+   *
+   * @default 'npm'
+   */
+  npmDir?: string;
+  /**
+   * git tag style, `npm` or `lerna`
+   *
+   * @default 'lerna'
+   */
+  tagStyle?: 'npm' | 'lerna';
+  /**
+   * Whether create GitHub release
+   *
+   * @default true
+   */
+  ghRelease?: boolean;
+  /**
+   * GitHub release name
+   */
+  ghReleaseName?: string;
+  /**
+   * Existing GitHub release id
+   */
+  ghReleaseId?: string;
+  /**
+   * Whether skip optionalDependencies packages publish
+   *
+   * @default false
+   */
+  skipOptionalPublish?: boolean;
+  /**
+   * Dry run without touching file system
+   *
+   * @default false
+   */
+  dryRun?: boolean;
+}
+//#endregion
+//#region src/api/pre-publish.d.ts
+declare function prePublish(userOptions: PrePublishOptions): Promise<void>;
+//#endregion
+//#region src/def/rename.d.ts
+/**
+ * Rename the NAPI-RS project
+ */
+interface RenameOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string;
+  /**
+   * Path to the folder where the npm packages put
+   *
+   * @default 'npm'
+   */
+  npmDir?: string;
+  /**
+   * The new name of the project
+   */
+  name?: string;
+  /**
+   * The new binary name *.node files
+   */
+  binaryName?: string;
+  /**
+   * The new package name of the project
+   */
+  packageName?: string;
+  /**
+   * Path to `Cargo.toml`
+   *
+   * @default 'Cargo.toml'
+   */
+  manifestPath?: string;
+  /**
+   * The new repository of the project
+   */
+  repository?: string;
+  /**
+   * The new description of the project
+   */
+  description?: string;
+}
+//#endregion
+//#region src/api/rename.d.ts
+declare function renameProject(userOptions: RenameOptions): Promise<void>;
+//#endregion
+//#region src/def/universalize.d.ts
+/**
+ * Combile built binaries into one universal binary
+ */
+interface UniversalizeOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string;
+  /**
+   * Path to the folder where all built `.node` files put, same as `--output-dir` of build command
+   *
+   * @default './'
+   */
+  outputDir?: string;
+}
+//#endregion
+//#region src/api/universalize.d.ts
+declare function universalizeBinaries(userOptions: UniversalizeOptions): Promise<void>;
+//#endregion
+//#region src/def/version.d.ts
+/**
+ * Update version in created npm packages
+ */
+interface VersionOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Path to `napi` config json file
+   */
+  configPath?: string;
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string;
+  /**
+   * Path to the folder where the npm packages put
+   *
+   * @default 'npm'
+   */
+  npmDir?: string;
+}
+//#endregion
+//#region src/api/version.d.ts
+declare function version(userOptions: VersionOptions): Promise<void>;
+//#endregion
+//#region src/utils/target.d.ts
+type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'openharmony';
+type NodeJSArch = 'arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 'riscv64' | 's390' | 's390x' | 'x32' | 'x64' | 'universal' | 'wasm32';
+interface Target {
+  triple: string;
+  platformArchABI: string;
+  platform: Platform;
+  arch: NodeJSArch;
+  abi: string | null;
+}
+/**
+ * A triple is a specific format for specifying a target architecture.
+ * Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on.
+ * The general format of the triple is `<arch><sub>-<vendor>-<sys>-<abi>` where:
+ *   - `arch` = The base CPU architecture, for example `x86_64`, `i686`, `arm`, `thumb`, `mips`, etc.
+ *   - `sub` = The CPU sub-architecture, for example `arm` has `v7`, `v7s`, `v5te`, etc.
+ *   - `vendor` = The vendor, for example `unknown`, `apple`, `pc`, `nvidia`, etc.
+ *   - `sys` = The system name, for example `linux`, `windows`, `darwin`, etc. none is typically used for bare-metal without an OS.
+ *   - `abi` = The ABI, for example `gnu`, `android`, `eabi`, etc.
+ */
+declare function parseTriple(rawTriple: string): Target;
+//#endregion
+//#region src/index.d.ts
 /**
  *
  * @usage
@@ -18,14 +524,16 @@ import { version } from './api/version.js';
  * })
  * ```
  */
-export declare class NapiCli {
-    artifacts: typeof collectArtifacts;
-    new: typeof newProject;
-    build: typeof buildProject;
-    createNpmDirs: typeof createNpmDirs;
-    prePublish: typeof prePublish;
-    rename: typeof renameProject;
-    universalize: typeof universalizeBinaries;
-    version: typeof version;
-}
-export { parseTriple } from './utils/target.js';
+declare class NapiCli {
+  artifacts: typeof collectArtifacts;
+  new: typeof newProject;
+  build: typeof buildProject;
+  createNpmDirs: typeof createNpmDirs;
+  prePublish: typeof prePublish;
+  rename: typeof renameProject;
+  universalize: typeof universalizeBinaries;
+  version: typeof version;
+}
+//#endregion
+export { NapiCli, parseTriple };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.ts","names":[],"sources":["../src/def/artifacts.d.ts","../src/api/artifacts.d.ts","../src/def/build.d.ts","../src/api/build.d.ts","../src/def/create-npm-dirs.d.ts","../src/api/create-npm-dirs.d.ts","../src/def/new.d.ts","../src/api/new.d.ts","../src/def/pre-publish.d.ts","../src/api/pre-publish.d.ts","../src/def/rename.d.ts","../src/api/rename.d.ts","../src/def/universalize.d.ts","../src/api/universalize.d.ts","../src/def/version.d.ts","../src/api/version.d.ts","../src/utils/target.d.ts","../src/index.d.ts"],"sourcesContent":["import { Command } from 'clipanion';\nexport declare abstract class BaseArtifactsCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    npmDir: string;\n    buildOutputDir?: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        outputDir: string;\n        npmDir: string;\n        buildOutputDir: string | undefined;\n    };\n}\n/**\n * Copy artifacts from Github Actions into npm packages and ready to publish\n */\nexport interface ArtifactsOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where all built `.node` files put, same as `--output-dir` of build command\n     *\n     * @default './artifacts'\n     */\n    outputDir?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * Path to the build output dir, only needed when targets contains `wasm32-wasi-*`\n     */\n    buildOutputDir?: string;\n}\nexport declare function applyDefaultArtifactsOptions(options: ArtifactsOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    npmDir: string;\n    /**\n     * Path to the build output dir, only needed when targets contains `wasm32-wasi-*`\n     */\n    buildOutputDir?: string;\n};\n","import { ArtifactsOptions } from '../def/artifacts.js';\nexport declare function collectArtifacts(userOptions: ArtifactsOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseBuildCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    target?: string;\n    cwd?: string;\n    manifestPath?: string;\n    configPath?: string;\n    packageJsonPath?: string;\n    targetDir?: string;\n    outputDir?: string;\n    platform?: boolean;\n    jsPackageName?: string;\n    constEnum?: boolean;\n    jsBinding?: string;\n    noJsBinding?: boolean;\n    dts?: string;\n    dtsHeader?: string;\n    noDtsHeader?: boolean;\n    dtsCache: boolean;\n    esm?: boolean;\n    strip?: boolean;\n    release?: boolean;\n    verbose?: boolean;\n    bin?: string;\n    package?: string;\n    profile?: string;\n    crossCompile?: boolean;\n    useCross?: boolean;\n    useNapiCross?: boolean;\n    watch?: boolean;\n    features?: string[];\n    allFeatures?: boolean;\n    noDefaultFeatures?: boolean;\n    getOptions(): {\n        target: string | undefined;\n        cwd: string | undefined;\n        manifestPath: string | undefined;\n        configPath: string | undefined;\n        packageJsonPath: string | undefined;\n        targetDir: string | undefined;\n        outputDir: string | undefined;\n        platform: boolean | undefined;\n        jsPackageName: string | undefined;\n        constEnum: boolean | undefined;\n        jsBinding: string | undefined;\n        noJsBinding: boolean | undefined;\n        dts: string | undefined;\n        dtsHeader: string | undefined;\n        noDtsHeader: boolean | undefined;\n        dtsCache: boolean;\n        esm: boolean | undefined;\n        strip: boolean | undefined;\n        release: boolean | undefined;\n        verbose: boolean | undefined;\n        bin: string | undefined;\n        package: string | undefined;\n        profile: string | undefined;\n        crossCompile: boolean | undefined;\n        useCross: boolean | undefined;\n        useNapiCross: boolean | undefined;\n        watch: boolean | undefined;\n        features: string[] | undefined;\n        allFeatures: boolean | undefined;\n        noDefaultFeatures: boolean | undefined;\n    };\n}\n/**\n * Build the NAPI-RS project\n */\nexport interface BuildOptions {\n    /**\n     * Build for the target triple, bypassed to `cargo build --target`\n     */\n    target?: string;\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     */\n    cwd?: string;\n    /**\n     * Path to `Cargo.toml`\n     */\n    manifestPath?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     */\n    packageJsonPath?: string;\n    /**\n     * Directory for all crate generated artifacts, see `cargo build --target-dir`\n     */\n    targetDir?: string;\n    /**\n     * Path to where all the built files would be put. Default to the crate folder\n     */\n    outputDir?: string;\n    /**\n     * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`\n     */\n    platform?: boolean;\n    /**\n     * Package name in generated js binding file. Only works with `--platform` flag\n     */\n    jsPackageName?: string;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.\n     */\n    jsBinding?: string;\n    /**\n     * Whether to disable the generation JS binding file. Only works with `--platform` flag.\n     */\n    noJsBinding?: boolean;\n    /**\n     * Path and filename of generated type def file. Relative to `--output-dir`\n     */\n    dts?: string;\n    /**\n     * Custom file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    dtsHeader?: string;\n    /**\n     * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    noDtsHeader?: boolean;\n    /**\n     * Whether to enable the dts cache, default to true\n     *\n     * @default true\n     */\n    dtsCache?: boolean;\n    /**\n     * Whether to emit an ESM JS binding file instead of CJS format. Only works with `--platform` flag.\n     */\n    esm?: boolean;\n    /**\n     * Whether strip the library to achieve the minimum file size\n     */\n    strip?: boolean;\n    /**\n     * Build in release mode\n     */\n    release?: boolean;\n    /**\n     * Verbosely log build command trace\n     */\n    verbose?: boolean;\n    /**\n     * Build only the specified binary\n     */\n    bin?: string;\n    /**\n     * Build the specified library or the one at cwd\n     */\n    package?: string;\n    /**\n     * Build artifacts with the specified profile\n     */\n    profile?: string;\n    /**\n     * [experimental] cross-compile for the specified target with `cargo-xwin` on windows and `cargo-zigbuild` on other platform\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets.\n     */\n    useNapiCross?: boolean;\n    /**\n     * watch the crate changes and build continuously with `cargo-watch` crates\n     */\n    watch?: boolean;\n    /**\n     * Space-separated list of features to activate\n     */\n    features?: string[];\n    /**\n     * Activate all available features\n     */\n    allFeatures?: boolean;\n    /**\n     * Do not activate the `default` feature\n     */\n    noDefaultFeatures?: boolean;\n}\nexport declare function applyDefaultBuildOptions(options: BuildOptions): {\n    /**\n     * Build for the target triple, bypassed to `cargo build --target`\n     */\n    target?: string;\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     */\n    cwd?: string;\n    /**\n     * Path to `Cargo.toml`\n     */\n    manifestPath?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     */\n    packageJsonPath?: string;\n    /**\n     * Directory for all crate generated artifacts, see `cargo build --target-dir`\n     */\n    targetDir?: string;\n    /**\n     * Path to where all the built files would be put. Default to the crate folder\n     */\n    outputDir?: string;\n    /**\n     * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`\n     */\n    platform?: boolean;\n    /**\n     * Package name in generated js binding file. Only works with `--platform` flag\n     */\n    jsPackageName?: string;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.\n     */\n    jsBinding?: string;\n    /**\n     * Whether to disable the generation JS binding file. Only works with `--platform` flag.\n     */\n    noJsBinding?: boolean;\n    /**\n     * Path and filename of generated type def file. Relative to `--output-dir`\n     */\n    dts?: string;\n    /**\n     * Custom file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    dtsHeader?: string;\n    /**\n     * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    noDtsHeader?: boolean;\n    dtsCache: boolean;\n    /**\n     * Whether to emit an ESM JS binding file instead of CJS format. Only works with `--platform` flag.\n     */\n    esm?: boolean;\n    /**\n     * Whether strip the library to achieve the minimum file size\n     */\n    strip?: boolean;\n    /**\n     * Build in release mode\n     */\n    release?: boolean;\n    /**\n     * Verbosely log build command trace\n     */\n    verbose?: boolean;\n    /**\n     * Build only the specified binary\n     */\n    bin?: string;\n    /**\n     * Build the specified library or the one at cwd\n     */\n    package?: string;\n    /**\n     * Build artifacts with the specified profile\n     */\n    profile?: string;\n    /**\n     * [experimental] cross-compile for the specified target with `cargo-xwin` on windows and `cargo-zigbuild` on other platform\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets.\n     */\n    useNapiCross?: boolean;\n    /**\n     * watch the crate changes and build continuously with `cargo-watch` crates\n     */\n    watch?: boolean;\n    /**\n     * Space-separated list of features to activate\n     */\n    features?: string[];\n    /**\n     * Activate all available features\n     */\n    allFeatures?: boolean;\n    /**\n     * Do not activate the `default` feature\n     */\n    noDefaultFeatures?: boolean;\n};\n","import { BuildOptions as RawBuildOptions } from '../def/build.js';\ntype OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';\ntype Output = {\n    kind: OutputKind;\n    path: string;\n};\ntype BuildOptions = RawBuildOptions & {\n    cargoOptions?: string[];\n};\nexport declare function buildProject(rawOptions: BuildOptions): Promise<{\n    task: Promise<Output[]>;\n    abort: () => void;\n}>;\nexport {};\n","import { Command } from 'clipanion';\nexport declare abstract class BaseCreateNpmDirsCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    dryRun: boolean;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        dryRun: boolean;\n    };\n}\n/**\n * Create npm package dirs for different platforms\n */\nexport interface CreateNpmDirsOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * Dry run without touching file system\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultCreateNpmDirsOptions(options: CreateNpmDirsOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    dryRun: boolean;\n};\n","import { CreateNpmDirsOptions } from '../def/create-npm-dirs.js';\nexport interface PackageMeta {\n    'dist-tags': {\n        [index: string]: string;\n    };\n}\nexport declare function createNpmDirs(userOptions: CreateNpmDirsOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseNewCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    $$path: string | undefined;\n    $$name?: string;\n    minNodeApiVersion: number;\n    packageManager: string;\n    license: string;\n    targets: string[];\n    enableDefaultTargets: boolean;\n    enableAllTargets: boolean;\n    enableTypeDef: boolean;\n    enableGithubActions: boolean;\n    testFramework: string;\n    dryRun: boolean;\n    getOptions(): {\n        path: string | undefined;\n        name: string | undefined;\n        minNodeApiVersion: number;\n        packageManager: string;\n        license: string;\n        targets: string[];\n        enableDefaultTargets: boolean;\n        enableAllTargets: boolean;\n        enableTypeDef: boolean;\n        enableGithubActions: boolean;\n        testFramework: string;\n        dryRun: boolean;\n    };\n}\n/**\n * Create a new project with pre-configured boilerplate\n */\nexport interface NewOptions {\n    /**\n     * The path where the NAPI-RS project will be created.\n     */\n    path?: string;\n    /**\n     * The name of the project, default to the name of the directory if not provided\n     */\n    name?: string;\n    /**\n     * The minimum Node-API version to support\n     *\n     * @default 4\n     */\n    minNodeApiVersion?: number;\n    /**\n     * The package manager to use. Only support yarn 4.x for now.\n     *\n     * @default 'yarn'\n     */\n    packageManager?: string;\n    /**\n     * License for open-sourced project\n     *\n     * @default 'MIT'\n     */\n    license?: string;\n    /**\n     * All targets the crate will be compiled for.\n     *\n     * @default []\n     */\n    targets?: string[];\n    /**\n     * Whether enable default targets\n     *\n     * @default true\n     */\n    enableDefaultTargets?: boolean;\n    /**\n     * Whether enable all targets\n     *\n     * @default false\n     */\n    enableAllTargets?: boolean;\n    /**\n     * Whether enable the `type-def` feature for typescript definitions auto-generation\n     *\n     * @default true\n     */\n    enableTypeDef?: boolean;\n    /**\n     * Whether generate preconfigured GitHub Actions workflow\n     *\n     * @default true\n     */\n    enableGithubActions?: boolean;\n    /**\n     * The JavaScript test framework to use, only support `ava` for now\n     *\n     * @default 'ava'\n     */\n    testFramework?: string;\n    /**\n     * Whether to run the command in dry-run mode\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultNewOptions(options: NewOptions): {\n    /**\n     * The path where the NAPI-RS project will be created.\n     */\n    path?: string;\n    /**\n     * The name of the project, default to the name of the directory if not provided\n     */\n    name?: string;\n    minNodeApiVersion: number;\n    packageManager: string;\n    license: string;\n    targets: string[];\n    enableDefaultTargets: boolean;\n    enableAllTargets: boolean;\n    enableTypeDef: boolean;\n    enableGithubActions: boolean;\n    testFramework: string;\n    dryRun: boolean;\n};\n","import { NewOptions as RawNewOptions } from '../def/new.js';\ntype NewOptions = Required<RawNewOptions>;\nexport declare function newProject(userOptions: RawNewOptions): Promise<void>;\nexport { NewOptions };\n","import { Command } from 'clipanion';\nexport declare abstract class BasePrePublishCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    tagStyle: string;\n    ghRelease: boolean;\n    ghReleaseName?: string;\n    ghReleaseId?: string;\n    skipOptionalPublish: boolean;\n    dryRun: boolean;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        tagStyle: string;\n        ghRelease: boolean;\n        ghReleaseName: string | undefined;\n        ghReleaseId: string | undefined;\n        skipOptionalPublish: boolean;\n        dryRun: boolean;\n    };\n}\n/**\n * Update package.json and copy addons into per platform packages\n */\nexport interface PrePublishOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * git tag style, `npm` or `lerna`\n     *\n     * @default 'lerna'\n     */\n    tagStyle?: 'npm' | 'lerna';\n    /**\n     * Whether create GitHub release\n     *\n     * @default true\n     */\n    ghRelease?: boolean;\n    /**\n     * GitHub release name\n     */\n    ghReleaseName?: string;\n    /**\n     * Existing GitHub release id\n     */\n    ghReleaseId?: string;\n    /**\n     * Whether skip optionalDependencies packages publish\n     *\n     * @default false\n     */\n    skipOptionalPublish?: boolean;\n    /**\n     * Dry run without touching file system\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultPrePublishOptions(options: PrePublishOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    tagStyle: string;\n    ghRelease: boolean;\n    /**\n     * GitHub release name\n     */\n    ghReleaseName?: string;\n    /**\n     * Existing GitHub release id\n     */\n    ghReleaseId?: string;\n    skipOptionalPublish: boolean;\n    dryRun: boolean;\n};\n","import { PrePublishOptions } from '../def/pre-publish.js';\nexport declare function prePublish(userOptions: PrePublishOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseRenameCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    $$name?: string;\n    binaryName?: string;\n    packageName?: string;\n    manifestPath: string;\n    repository?: string;\n    description?: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        name: string | undefined;\n        binaryName: string | undefined;\n        packageName: string | undefined;\n        manifestPath: string;\n        repository: string | undefined;\n        description: string | undefined;\n    };\n}\n/**\n * Rename the NAPI-RS project\n */\nexport interface RenameOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * The new name of the project\n     */\n    name?: string;\n    /**\n     * The new binary name *.node files\n     */\n    binaryName?: string;\n    /**\n     * The new package name of the project\n     */\n    packageName?: string;\n    /**\n     * Path to `Cargo.toml`\n     *\n     * @default 'Cargo.toml'\n     */\n    manifestPath?: string;\n    /**\n     * The new repository of the project\n     */\n    repository?: string;\n    /**\n     * The new description of the project\n     */\n    description?: string;\n}\nexport declare function applyDefaultRenameOptions(options: RenameOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    /**\n     * The new name of the project\n     */\n    name?: string;\n    /**\n     * The new binary name *.node files\n     */\n    binaryName?: string;\n    /**\n     * The new package name of the project\n     */\n    packageName?: string;\n    manifestPath: string;\n    /**\n     * The new repository of the project\n     */\n    repository?: string;\n    /**\n     * The new description of the project\n     */\n    description?: string;\n};\n","import { RenameOptions } from '../def/rename.js';\nexport declare function renameProject(userOptions: RenameOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseUniversalizeCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        outputDir: string;\n    };\n}\n/**\n * Combile built binaries into one universal binary\n */\nexport interface UniversalizeOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where all built `.node` files put, same as `--output-dir` of build command\n     *\n     * @default './'\n     */\n    outputDir?: string;\n}\nexport declare function applyDefaultUniversalizeOptions(options: UniversalizeOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n};\n","import { UniversalizeOptions } from '../def/universalize.js';\nexport declare function universalizeBinaries(userOptions: UniversalizeOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseVersionCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n    };\n}\n/**\n * Update version in created npm packages\n */\nexport interface VersionOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n}\nexport declare function applyDefaultVersionOptions(options: VersionOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n};\n","import { VersionOptions } from '../def/version.js';\nexport declare function version(userOptions: VersionOptions): Promise<void>;\n","export type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'openharmony';\nexport declare const UNIVERSAL_TARGETS: {\n    readonly 'universal-apple-darwin': readonly [\"aarch64-apple-darwin\", \"x86_64-apple-darwin\"];\n};\nexport declare const AVAILABLE_TARGETS: readonly [\"aarch64-apple-darwin\", \"aarch64-linux-android\", \"aarch64-unknown-linux-gnu\", \"aarch64-unknown-linux-musl\", \"aarch64-unknown-linux-ohos\", \"aarch64-pc-windows-msvc\", \"x86_64-apple-darwin\", \"x86_64-pc-windows-msvc\", \"x86_64-unknown-linux-gnu\", \"x86_64-unknown-linux-musl\", \"x86_64-unknown-linux-ohos\", \"x86_64-unknown-freebsd\", \"i686-pc-windows-msvc\", \"armv7-unknown-linux-gnueabihf\", \"armv7-unknown-linux-musleabihf\", \"armv7-linux-androideabi\", \"universal-apple-darwin\", \"riscv64gc-unknown-linux-gnu\", \"powerpc64le-unknown-linux-gnu\", \"s390x-unknown-linux-gnu\", \"wasm32-wasi-preview1-threads\", \"wasm32-wasip1-threads\"];\nexport type TargetTriple = (typeof AVAILABLE_TARGETS)[number];\nexport declare const DEFAULT_TARGETS: readonly [\"x86_64-apple-darwin\", \"aarch64-apple-darwin\", \"x86_64-pc-windows-msvc\", \"x86_64-unknown-linux-gnu\"];\nexport declare const TARGET_LINKER: Record<string, string>;\ntype NodeJSArch = 'arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 'riscv64' | 's390' | 's390x' | 'x32' | 'x64' | 'universal' | 'wasm32';\nexport declare const NodeArchToCpu: Record<string, string>;\nexport declare const UniArchsByPlatform: Partial<Record<Platform, NodeJSArch[]>>;\nexport interface Target {\n    triple: string;\n    platformArchABI: string;\n    platform: Platform;\n    arch: NodeJSArch;\n    abi: string | null;\n}\n/**\n * A triple is a specific format for specifying a target architecture.\n * Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on.\n * The general format of the triple is `<arch><sub>-<vendor>-<sys>-<abi>` where:\n *   - `arch` = The base CPU architecture, for example `x86_64`, `i686`, `arm`, `thumb`, `mips`, etc.\n *   - `sub` = The CPU sub-architecture, for example `arm` has `v7`, `v7s`, `v5te`, etc.\n *   - `vendor` = The vendor, for example `unknown`, `apple`, `pc`, `nvidia`, etc.\n *   - `sys` = The system name, for example `linux`, `windows`, `darwin`, etc. none is typically used for bare-metal without an OS.\n *   - `abi` = The ABI, for example `gnu`, `android`, `eabi`, etc.\n */\nexport declare function parseTriple(rawTriple: string): Target;\nexport declare function getSystemDefaultTarget(): Target;\nexport declare function getTargetLinker(target: string): string | undefined;\nexport declare function targetToEnvVar(target: string): string;\nexport {};\n","import { collectArtifacts } from './api/artifacts.js';\nimport { buildProject } from './api/build.js';\nimport { createNpmDirs } from './api/create-npm-dirs.js';\nimport { newProject } from './api/new.js';\nimport { prePublish } from './api/pre-publish.js';\nimport { renameProject } from './api/rename.js';\nimport { universalizeBinaries } from './api/universalize.js';\nimport { version } from './api/version.js';\n/**\n *\n * @usage\n *\n * ```ts\n * const cli = new NapiCli()\n *\n * cli.build({\n *   cwd: '/path/to/your/project',\n * })\n * ```\n */\nexport declare class NapiCli {\n    artifacts: typeof collectArtifacts;\n    new: typeof newProject;\n    build: typeof buildProject;\n    createNpmDirs: typeof createNpmDirs;\n    prePublish: typeof prePublish;\n    rename: typeof renameProject;\n    universalize: typeof universalizeBinaries;\n    version: typeof version;\n}\nexport { parseTriple } from './utils/target.js';\n"],"mappings":";;;AAGA,IAAW,mBAAmB,CAAC,EAAG;;;;ACFlC,IAAW,mBAAmB;CAAC;CAAI,MAAM;CAAkB,MAAM;AAAQ;;;;ACEzE,IAAW,eAAe,CAAC,EAAG;;;;ACF9B,IAAI,aAAa,CAAC,EAAG;AACrB,IAAI,SAAS,CAAC,IAAA,MAAA,UAAA;AACd,IAAI,iBAAe,CAAC,IAAA,MAAA,YAAA;AACpB,IAAW,eAAK;CAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;ACDhB,IAAW,uBAAuB,CAAC,EAAG;;;;ACDtC,IAAW,gBAAM;CAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;ACCjB,IAAW,aAAa,CAAC,EAAG;;;;ACD5B,IAAW,aAAa;CAAC;CAAI,MAAM;CAAe,MAAM;AAAQ;;;;ACChE,IAAW,oBAAoB,CAAC,EAAG;;;;ACFnC,IAAW,aAAa;CAAC;CAAI,MAAM;CAAmB,MAAM;AAAQ;;;;ACEpE,IAAW,gBAAgB,CAAC,EAAG;;;;ACF/B,IAAW,gBAAgB;CAAC;CAAI,MAAM;CAAe,MAAM;AAAQ;;;;ACEnE,IAAW,sBAAsB,CAAC,EAAG;;;;ACFrC,IAAW,uBAAuB;CAAC;CAAI,MAAM;CAAqB,MAAM;AAAQ;;;;ACEhF,IAAW,iBAAiB,CAAC,EAAG;;;;ACFhC,IAAW,UAAU;CAAC;CAAI,MAAM;CAAgB,MAAM;AAAQ;;;;ACD9D,IAAW,WAAW,CAAC,GAAG,MAAM,OAAO,QAAS;AAMhD,IAAI,aAAa,CAAC,CAAE;AAGpB,IAAW,SAAS;CAAC;CAAI,MAAM;CAAU,MAAM;AAAW;AAC1D,IAAW,cAAc,CAAC,IAAI,MAAM,MAAO;;;;ACF3C,IAAE,UAAA;CAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA"}