@napi-rs/cli 2.15.2 → 3.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+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';
+/**
+ *
+ * @usage
+ *
+ * ```ts
+ * const cli = new NapiCli()
+ *
+ * cli.build({
+ *   cwd: '/path/to/your/project',
+ * })
+ * ```
+ */
+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;
+}

package/dist/index.js

@@ -0,0 +1,30 @@
+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';
+/**
+ *
+ * @usage
+ *
+ * ```ts
+ * const cli = new NapiCli()
+ *
+ * cli.build({
+ *   cwd: '/path/to/your/project',
+ * })
+ * ```
+ */
+export class NapiCli {
+    artifacts = collectArtifacts;
+    new = newProject;
+    build = buildProject;
+    createNpmDirs = createNpmDirs;
+    prePublish = prePublish;
+    rename = renameProject;
+    universalize = universalizeBinaries;
+    version = version;
+}

package/dist/utils/__tests__/target.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/target.spec.js

@@ -0,0 +1,10 @@
+import os from 'os';
+import test from 'ava';
+import { parseTriple, getSystemDefaultTarget, AVAILABLE_TARGETS, } from '../target.js';
+test('should parse triple correctly', (t) => {
+    t.snapshot(AVAILABLE_TARGETS.map(parseTriple));
+});
+test('should get system default target correctly', (t) => {
+    const target = getSystemDefaultTarget();
+    t.is(target.platform, os.platform());
+});

package/dist/utils/__tests__/typegen.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/typegen.spec.js

@@ -0,0 +1,37 @@
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import test from 'ava';
+import { correctStringIdent, processTypeDef } from '../typegen.js';
+test('should ident string correctly', (t) => {
+    const input = `
+  /**
+   * should keep
+   * class A {
+   * foo = () => {}
+   *   bar = () => {}
+   * }
+   */
+  class A {
+    foo() {
+      a = b
+    }
+  
+  bar = () => {
+  
+  }
+      boz = 1
+    }
+  
+  namespace B {
+      namespace C {
+  type D = A
+      }
+  }
+`;
+    t.snapshot(correctStringIdent(input, 0), 'original ident is 0');
+    t.snapshot(correctStringIdent(input, 2), 'original ident is 2');
+});
+test('should process type def correctly', async (t) => {
+    const dts = await processTypeDef(join(fileURLToPath(import.meta.url), '../', '__fixtures__', 'napi_type_def'));
+    t.snapshot(dts);
+});

package/dist/utils/__tests__/version.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/version.spec.js

@@ -0,0 +1,5 @@
+import test from 'ava';
+import { napiEngineRequirement, NapiVersion } from '../version.js';
+test('should generate correct napi engine requirement', (t) => {
+    t.snapshot(Object.values(NapiVersion).filter((v) => typeof v === 'number').map(napiEngineRequirement));
+});

package/dist/utils/cargo.d.ts

@@ -0,0 +1 @@
+export declare function tryInstallCargoBinary(name: string, bin: string): void;

package/dist/utils/cargo.js

@@ -0,0 +1,33 @@
+import { execSync } from 'child_process';
+import { debug } from './log.js';
+export function tryInstallCargoBinary(name, bin) {
+    if (detectCargoBinary(bin)) {
+        debug('Cargo binary already installed: %s', name);
+        return;
+    }
+    try {
+        debug('Installing cargo binary: %s', name);
+        execSync(`cargo install ${name}`, {
+            stdio: 'inherit',
+        });
+    }
+    catch (e) {
+        throw new Error(`Failed to install cargo binary: ${name}`, {
+            cause: e,
+        });
+    }
+}
+function detectCargoBinary(bin) {
+    debug('Detecting cargo binary: %s', bin);
+    try {
+        execSync(`cargo help ${bin}`, {
+            stdio: 'ignore',
+        });
+        debug('Cargo binary detected: %s', bin);
+        return true;
+    }
+    catch (e) {
+        debug('Cargo binary not detected: %s', bin);
+        return false;
+    }
+}

package/dist/utils/ci.d.ts

@@ -0,0 +1,11 @@
+import { TargetTriple } from './target.js';
+export declare const CIConfig: Partial<Record<TargetTriple, {
+    host: string;
+    build_image?: string;
+    build_setup?: string[];
+    test?: boolean;
+    test_image?: string;
+    test_setup?: string[];
+    yarn_cpu?: string;
+    yarn_libc?: string;
+}>>;

package/dist/utils/ci.js

@@ -0,0 +1,86 @@
+export const CIConfig = {
+    'x86_64-apple-darwin': {
+        host: 'macos-latest',
+    },
+    'x86_64-pc-windows-msvc': {
+        host: 'windows-latest',
+    },
+    'i686-pc-windows-msvc': {
+        host: 'windows-latest',
+        test: false,
+    },
+    'x86_64-unknown-linux-gnu': {
+        host: 'ubuntu-latest',
+        build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian',
+    },
+    'x86_64-unknown-linux-musl': {
+        host: 'ubuntu-latest',
+        build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine',
+        test_image: 'node:${{ matrix.node }}-alpine',
+        yarn_libc: 'musl',
+    },
+    'aarch64-apple-darwin': {
+        host: 'macos-latest',
+        build_setup: [
+            'sudo rm -Rf /Library/Developer/CommandLineTools/SDKs/*',
+            'export CC=$(xcrun -f clang)',
+            'export CXX=$(xcrun -f clang++)',
+            'export SDK_ROOT=$(xcrun --sdk macosx --show-sdk-path)',
+            'export CFLAGS="-isysroot $SDK_ROOT -isystem $SDK_ROOT"',
+        ],
+        test: false,
+    },
+    'aarch64-unknown-linux-gnu': {
+        host: 'ubuntu-latest',
+        build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64',
+        build_setup: [
+            'sudo apt-get update',
+            'sudo apt-get install g++-aarch64-linux-gnu gcc-aarch64-linux-gnu -y',
+            'export CARGO_BUILD_TARGET=x86_64-unknown-linux-gnu',
+        ],
+        test_image: 'ghcr.io/napi-rs/napi-rs/nodejs:aarch64-${{ matrix.node }}',
+        yarn_cpu: 'arm64',
+    },
+    'aarch64-unknown-linux-musl': {
+        host: 'ubuntu-latest',
+        build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine',
+        build_setup: ['rustup target add aarch64-unknown-linux-musl'],
+        test_image: 'multiarch/alpine:aarch64-latest-stable',
+        test_setup: ['apk add nodejs npm yarn'],
+        yarn_cpu: 'arm64',
+        yarn_libc: 'musl',
+    },
+    'aarch64-pc-windows-msvc': {
+        host: 'windows-latest',
+        test: false,
+    },
+    'armv7-unknown-linux-gnueabihf': {
+        host: 'ubuntu-latest',
+        build_setup: [
+            'sudo apt-get update',
+            'sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf -y',
+        ],
+        yarn_cpu: 'arm',
+        test_image: 'ghcr.io/napi-rs/napi-rs/nodejs:armhf-${{ matrix.node }}',
+    },
+    'aarch64-linux-android': {
+        host: 'ubuntu-latest',
+        build_setup: [
+            'export CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang"',
+            'export CC="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang"',
+            'export CXX="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang++"',
+            'export PATH="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${PATH}"',
+        ],
+        test: false,
+    },
+    'armv7-linux-androideabi': {
+        host: 'ubuntu-latest',
+        build_setup: [
+            'export CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi24-clang"',
+            'export CC="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi24-clang"',
+            'export CXX="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi24-clang++"',
+            'export PATH="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${PATH}"',
+        ],
+        test: false,
+    },
+};

package/dist/utils/config.d.ts

@@ -0,0 +1,65 @@
+import { Target } from './target.js';
+interface UserNapiConfig {
+    /**
+     * Name of the binary to be generated, default to `index`
+     */
+    binaryName?: string;
+    /**
+     * Name of the npm package, default to the name of root package.json name
+     *
+     * Always given `@scope/pkg` and arch suffix will be appended like `@scope/pkg-linux-gnu-x64`
+     */
+    packageName?: string;
+    /**
+     * All targets the crate will be compiled for
+     */
+    targets?: string[];
+    /**
+     * The npm client project uses.
+     */
+    npmClient?: string;
+    /**
+     * @deprecated binaryName instead
+     */
+    name?: string;
+    /**
+     * @deprecated use packageName instead
+     */
+    package?: {
+        name?: string;
+    };
+    /**
+     * @deprecated use targets instead
+     */
+    triples?: {
+        /**
+         * Whether enable default targets
+         */
+        default: boolean;
+        /**
+         * Additional targets to be compiled for
+         */
+        additional?: string[];
+    };
+}
+interface CommonPackageJsonFields {
+    name: string;
+    version: string;
+    description?: string;
+    keywords?: string[];
+    author?: string;
+    authors?: string[];
+    license?: string;
+    repository?: any;
+    homepage?: any;
+    engines?: Record<string, string>;
+    publishConfig?: any;
+    bugs?: any;
+    napi?: UserNapiConfig;
+}
+export type NapiConfig = Required<Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>> & {
+    targets: Target[];
+    packageJson: CommonPackageJsonFields;
+};
+export declare function readNapiConfig(path: string): Promise<NapiConfig>;
+export {};

package/dist/utils/config.js

@@ -0,0 +1,42 @@
+import { merge, omit } from 'lodash-es';
+import { fileExists, readFileAsync } from './misc.js';
+import { DEFAULT_TARGETS, parseTriple } from './target.js';
+export async function readNapiConfig(path) {
+    if (!(await fileExists(path))) {
+        throw new Error(`napi-rs config not found at ${path}`);
+    }
+    // May support multiple config sources later on.
+    const content = await readFileAsync(path, 'utf8');
+    let pkgJson;
+    try {
+        pkgJson = JSON.parse(content);
+    }
+    catch (e) {
+        throw new Error('Failed to parse napi-rs config', {
+            cause: e,
+        });
+    }
+    const userNapiConfig = pkgJson.napi ?? {};
+    const napiConfig = merge({
+        binaryName: 'index',
+        packageName: pkgJson.name,
+        targets: [],
+        packageJson: pkgJson,
+        npmClient: 'npm',
+    }, omit(userNapiConfig, 'targets'));
+    let targets = userNapiConfig.targets ?? [];
+    // compatible with old config
+    if (userNapiConfig.package?.name) {
+        napiConfig.packageName = userNapiConfig.package.name;
+    }
+    if (!targets.length) {
+        if (userNapiConfig.triples?.default) {
+            targets = targets.concat(DEFAULT_TARGETS);
+        }
+        if (userNapiConfig.triples?.additional?.length) {
+            targets = targets.concat(userNapiConfig.triples.additional);
+        }
+    }
+    napiConfig.targets = targets.map(parseTriple);
+    return napiConfig;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './ci.js';
+export * from './log.js';
+export * from './misc.js';
+export * from './target.js';
+export * from './version.js';
+export * from './metadata.js';
+export * from './config.js';
+export * from './cargo.js';
+export * from './typegen.js';

package/dist/utils/index.js

@@ -0,0 +1,9 @@
+export * from './ci.js';
+export * from './log.js';
+export * from './misc.js';
+export * from './target.js';
+export * from './version.js';
+export * from './metadata.js';
+export * from './config.js';
+export * from './cargo.js';
+export * from './typegen.js';

package/dist/utils/log.d.ts

@@ -0,0 +1,10 @@
+import rawDebug from 'debug';
+declare module 'debug' {
+    interface Debugger {
+        info: typeof console.error;
+        warn: typeof console.error;
+        error: typeof console.error;
+    }
+}
+export declare const debugFactory: (namespace: string) => rawDebug.Debugger;
+export declare const debug: rawDebug.Debugger;

package/dist/utils/log.js

@@ -0,0 +1,14 @@
+import * as colors from 'colorette';
+import rawDebug from 'debug';
+// debug('%i', 'This is an info')
+rawDebug.formatters.i = (v) => {
+    return colors.green(v);
+};
+export const debugFactory = (namespace) => {
+    const debug = rawDebug(`napi:${namespace}`);
+    debug.info = (...args) => console.error(colors.black(colors.bgGreen(' INFO ')), ...args);
+    debug.warn = (...args) => console.error(colors.black(colors.bgYellow(' WARNING ')), ...args);
+    debug.error = (...args) => console.error(colors.white(colors.bgRed(' ERROR ')), ...args.map((arg) => arg instanceof Error ? arg.stack ?? arg.message : arg));
+    return debug;
+};
+export const debug = debugFactory('utils');

package/dist/utils/metadata.d.ts

@@ -0,0 +1,24 @@
+export type CrateTargetKind = 'bin' | 'example' | 'test' | 'bench' | 'lib' | 'rlib' | 'cdylib' | 'custom-build';
+export interface CrateTarget {
+    name: string;
+    kind: CrateTargetKind[];
+    crate_types: CrateTargetKind[];
+}
+export interface Crate {
+    id: string;
+    name: string;
+    src_path: string;
+    version: string;
+    edition: string;
+    targets: CrateTarget[];
+    features: Record<string, string[]>;
+    manifest_path: string;
+}
+export interface CargoWorkspaceMetadata {
+    version: number;
+    packages: Crate[];
+    workspace_members: string[];
+    target_directory: string;
+    workspace_root: string;
+}
+export declare function parseMetadata(manifestPath: string): CargoWorkspaceMetadata;

package/dist/utils/metadata.js

@@ -0,0 +1,19 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+export function parseMetadata(manifestPath) {
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error(`No crate found in manifest: ${manifestPath}`);
+    }
+    const cmd = `cargo metadata --manifest-path ${manifestPath} --format-version 1 --no-deps`;
+    try {
+        const output = execSync(cmd, {
+            encoding: 'utf-8',
+        });
+        return JSON.parse(output);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse cargo metadata output by command: ${cmd}`, {
+            cause: e,
+        });
+    }
+}

package/dist/utils/misc.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+import { readFile, writeFile, copyFile, mkdir, unlink, stat, readdir } from 'fs';
+export declare const readFileAsync: typeof readFile.__promisify__;
+export declare const writeFileAsync: typeof writeFile.__promisify__;
+export declare const unlinkAsync: typeof unlink.__promisify__;
+export declare const copyFileAsync: typeof copyFile.__promisify__;
+export declare const mkdirAsync: typeof mkdir.__promisify__;
+export declare const statAsync: typeof stat.__promisify__;
+export declare const readdirAsync: typeof readdir.__promisify__;
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function pick<O, K extends keyof O>(o: O, ...keys: K[]): Pick<O, K>;
+export declare function updatePackageJson(path: string, partial: Record<string, any>): Promise<void>;
+export declare const CLI_VERSION: any;

package/dist/utils/misc.js

@@ -0,0 +1,35 @@
+import { readFile, writeFile, copyFile, mkdir, unlink, stat, readdir } from 'fs';
+import { createRequire } from 'module';
+import { promisify } from 'util';
+import { debug } from './log.js';
+const require = createRequire(import.meta.url);
+const pkgJson = require('../../package.json');
+export const readFileAsync = promisify(readFile);
+export const writeFileAsync = promisify(writeFile);
+export const unlinkAsync = promisify(unlink);
+export const copyFileAsync = promisify(copyFile);
+export const mkdirAsync = promisify(mkdir);
+export const statAsync = promisify(stat);
+export const readdirAsync = promisify(readdir);
+export async function fileExists(path) {
+    const exists = await statAsync(path)
+        .then(() => true)
+        .catch(() => false);
+    return exists;
+}
+export function pick(o, ...keys) {
+    return keys.reduce((acc, key) => {
+        acc[key] = o[key];
+        return acc;
+    }, {});
+}
+export async function updatePackageJson(path, partial) {
+    const exists = await fileExists(path);
+    if (!exists) {
+        debug(`File not exists ${path}`);
+        return;
+    }
+    const old = require(path);
+    await writeFileAsync(path, JSON.stringify({ ...old, ...partial }, null, 2));
+}
+export const CLI_VERSION = pkgJson.version;

package/dist/utils/target.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare const AVAILABLE_TARGETS: readonly ["aarch64-apple-darwin", "aarch64-linux-android", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "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-freebsd", "i686-pc-windows-msvc", "armv7-unknown-linux-gnueabihf", "armv7-linux-androideabi", "universal-apple-darwin"];
+export type TargetTriple = (typeof AVAILABLE_TARGETS)[number];
+export declare const DEFAULT_TARGETS: readonly ["x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-unknown-linux-gnu"];
+export declare const TARGET_LINKER: Record<string, string>;
+type NodeJSArch = 'arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | 'universal';
+export declare const NodeArchToCpu: Record<string, string>;
+export declare const UniArchsByPlatform: Partial<Record<NodeJS.Platform, NodeJSArch[]>>;
+export interface Target {
+    triple: string;
+    platformArchABI: string;
+    platform: NodeJS.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.
+ */
+export declare function parseTriple(rawTriple: string): Target;
+export declare function getSystemDefaultTarget(): Target;
+export declare function getTargetLinker(target: string): string | undefined;
+export declare function targetToEnvVar(target: string): string;
+export {};

package/dist/utils/target.js

@@ -0,0 +1,109 @@
+import { execSync } from 'child_process';
+export const AVAILABLE_TARGETS = [
+    'aarch64-apple-darwin',
+    'aarch64-linux-android',
+    'aarch64-unknown-linux-gnu',
+    'aarch64-unknown-linux-musl',
+    '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-freebsd',
+    'i686-pc-windows-msvc',
+    'armv7-unknown-linux-gnueabihf',
+    'armv7-linux-androideabi',
+    'universal-apple-darwin',
+];
+export const DEFAULT_TARGETS = [
+    'x86_64-apple-darwin',
+    'x86_64-pc-windows-msvc',
+    'x86_64-unknown-linux-gnu',
+];
+export const TARGET_LINKER = {
+    'aarch64-unknown-linux-gnu': 'aarch64-linux-gnu-gcc',
+    'armv7-unknown-linux-gnueabihf': 'arm-linux-gnueabihf-gcc',
+    'aarch64-unknown-linux-musl': 'aarch64-linux-musl-gcc',
+};
+const CpuToNodeArch = {
+    x86_64: 'x64',
+    aarch64: 'arm64',
+    i686: 'ia32',
+    armv7: 'arm',
+};
+export const NodeArchToCpu = {
+    x64: 'x86_64',
+    arm64: 'aarch64',
+    ia32: 'i686',
+    arm: 'armv7',
+};
+const SysToNodePlatform = {
+    linux: 'linux',
+    freebsd: 'freebsd',
+    darwin: 'darwin',
+    windows: 'win32',
+};
+export const UniArchsByPlatform = {
+    darwin: ['x64', 'arm64'],
+};
+/**
+ * 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.
+ */
+export function parseTriple(rawTriple) {
+    const triple = rawTriple.endsWith('eabi')
+        ? `${rawTriple.slice(0, -4)}-eabi`
+        : rawTriple;
+    const triples = triple.split('-');
+    let cpu;
+    let sys;
+    let abi = null;
+    if (triples.length === 2) {
+        // aarch64-fuchsia
+        // ^ cpu   ^ sys
+        ;
+        [cpu, sys] = triples;
+    }
+    else {
+        // aarch64-unknown-linux-musl
+        // ^ cpu           ^ sys ^ abi
+        // aarch64-apple-darwin
+        // ^ cpu         ^ sys  (abi is None)
+        ;
+        [cpu, , sys, abi = null] = triples;
+    }
+    const platform = SysToNodePlatform[sys] ?? sys;
+    const arch = CpuToNodeArch[cpu] ?? cpu;
+    return {
+        triple: rawTriple,
+        platformArchABI: abi ? `${platform}-${arch}-${abi}` : `${platform}-${arch}`,
+        platform,
+        arch,
+        abi,
+    };
+}
+export function getSystemDefaultTarget() {
+    const host = execSync(`rustc -vV`, {
+        env: process.env,
+    })
+        .toString('utf8')
+        .split('\n')
+        .find((line) => line.startsWith('host: '));
+    const triple = host?.slice('host: '.length);
+    if (!triple) {
+        throw new TypeError(`Can not parse target triple from host`);
+    }
+    return parseTriple(triple);
+}
+export function getTargetLinker(target) {
+    return TARGET_LINKER[target];
+}
+export function targetToEnvVar(target) {
+    return target.replace(/-/g, '_').toUpperCase();
+}

package/dist/utils/typegen.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_TYPE_DEF_HEADER = "/* auto-generated by NAPI-RS */\n/* eslint-disable */\n";
+export declare function processTypeDef(intermediateTypeFile: string, header?: string): Promise<string>;
+export declare function correctStringIdent(src: string, ident: number): string;