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

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

@@ -0,0 +1,124 @@
+/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
+function loadNapiModule(binaryName, packageName) {
+    const { existsSync, readFileSync } = require('fs');
+    const { join } = require('path');
+    const { platform, arch } = process;
+    const candidates = [];
+    function isMusl() {
+        // For Node 10
+        if (!process.report || typeof process.report.getReport !== 'function') {
+            try {
+                const lddPath = require('child_process')
+                    .execSync('which ldd')
+                    .toString()
+                    .trim();
+                return readFileSync(lddPath, 'utf8').includes('musl');
+            }
+            catch (e) {
+                return true;
+            }
+        }
+        else {
+            // @ts-expect-error
+            const { glibcVersionRuntime } = process.report.getReport().header;
+            return !glibcVersionRuntime;
+        }
+    }
+    switch (platform) {
+        case 'android':
+            switch (arch) {
+                case 'arm64':
+                    candidates.push('android-arm64');
+                    break;
+                case 'arm':
+                    candidates.push('android-arm-eabi');
+                    break;
+            }
+            break;
+        case 'win32':
+            switch (arch) {
+                case 'x64':
+                    candidates.push('win32-x64-msvc');
+                    break;
+                case 'ia32':
+                    candidates.push('win32-ia32-msvc');
+                    break;
+                case 'arm64':
+                    candidates.push('win32-arm64-msvc');
+                    break;
+            }
+            break;
+        case 'darwin':
+            candidates.push('darwin-universal');
+            switch (arch) {
+                case 'x64':
+                    candidates.push('darwin-x64');
+                    break;
+                case 'arm64':
+                    candidates.push('darwin-arm64');
+                    break;
+            }
+            break;
+        case 'freebsd':
+            if (arch === 'x64') {
+                candidates.push('freebsd-x64');
+            }
+            break;
+        case 'linux':
+            switch (arch) {
+                case 'x64':
+                    if (isMusl()) {
+                        candidates.push('linux-x64-musl');
+                    }
+                    else {
+                        candidates.push('linux-x64-gnu');
+                    }
+                    break;
+                case 'arm64':
+                    if (isMusl()) {
+                        candidates.push('linux-arm64-musl');
+                    }
+                    else {
+                        candidates.push('linux-arm64-gnu');
+                    }
+                    break;
+                case 'arm':
+                    candidates.push('linux-arm-gnueabihf');
+                    break;
+            }
+            break;
+    }
+    let nativeBinding;
+    let loadError;
+    for (const suffix of candidates) {
+        const localPath = join(__dirname, `${binaryName}.${suffix}.node`);
+        const pkgPath = `${packageName}-${suffix}`;
+        try {
+            if (existsSync(localPath)) {
+                nativeBinding = require(localPath);
+            }
+            else {
+                nativeBinding = require(pkgPath);
+            }
+        }
+        catch (e) {
+            loadError = e;
+            continue;
+        }
+        loadError = null;
+        break;
+    }
+    if (!nativeBinding) {
+        if (loadError) {
+            throw loadError;
+        }
+        throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+    }
+    return nativeBinding;
+}
+export function createJsBinding(localName, pkgName) {
+    return `${loadNapiModule.toString()}
+
+module.exports = loadNapiModule('${localName}', '${pkgName}')
+`;
+}

package/dist/api/templates/lib.rs.d.ts

@@ -0,0 +1 @@
+export declare const createLibRs: () => string;

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

@@ -0,0 +1,10 @@
+export const createLibRs = () => `#![deny(clippy::all)]
+
+#[macro_use]
+extern crate napi_derive;
+
+#[napi]
+pub fn sum(a: i32, b: i32) -> i32 {
+  a + b
+}
+`;

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

@@ -0,0 +1,8 @@
+export declare const createPackageJson: ({ name, binaryName, targets, license, engineRequirement, cliVersion, }: {
+    name: string;
+    binaryName: string;
+    targets: string[];
+    license: string;
+    engineRequirement: string;
+    cliVersion: string;
+}) => string;

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

@@ -0,0 +1,30 @@
+export const createPackageJson = ({ name, binaryName, targets, license, engineRequirement, cliVersion, }) => {
+    return `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "license": "${license}",
+  "engines": {
+    "node": "${engineRequirement}"
+  },
+  "napi": {
+    "name": "${binaryName}",
+    "targets": [
+      ${targets.map((t) => `"${t}"`).join(',\n      ')}
+    ]
+  },
+  "scripts": {
+    "test": "yarn build:debug --platform && node -e \\"assert(require('.').sum(1, 2) === 3)\\"",
+    "build": "napi build --release --platform --strip",
+    "build:debug": "napi build",
+    "prepublishOnly": "napi prepublish -t npm",
+    "artifacts": "napi artifacts",
+    "universal": "napi universal",
+    "version": "napi version"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^${cliVersion}"
+  }
+}`;
+};

package/dist/api/universalize.d.ts

@@ -0,0 +1,2 @@
+import { UniversalizeOptions } from '../def/universalize.js';
+export declare function universalizeBinaries(userOptions: UniversalizeOptions): Promise<void>;

package/dist/api/universalize.js

@@ -0,0 +1,38 @@
+import { spawnSync } from 'child_process';
+import { join, resolve } from 'path';
+import { applyDefaultUniversalizeOptions, } from '../def/universalize.js';
+import { readNapiConfig } from '../utils/config.js';
+import { debugFactory } from '../utils/log.js';
+import { fileExists } from '../utils/misc.js';
+import { UniArchsByPlatform } from '../utils/target.js';
+const debug = debugFactory('universalize');
+const universalizers = {
+    darwin: (inputs, output) => {
+        spawnSync('lipo', ['-create', '-output', output, ...inputs], {
+            stdio: 'inherit',
+        });
+    },
+};
+export async function universalizeBinaries(userOptions) {
+    const options = applyDefaultUniversalizeOptions(userOptions);
+    const packageJsonPath = join(options.cwd, options.packageJsonPath);
+    const config = await readNapiConfig(packageJsonPath);
+    const target = config.targets.find((t) => t.platform === process.platform && t.arch === 'universal');
+    if (!target) {
+        throw new Error(`'universal' arch for platform '${process.platform}' not found in config!`);
+    }
+    const srcFiles = UniArchsByPlatform[process.platform]?.map((arch) => `${config.binaryName}.${process.platform}-${arch}.node`);
+    if (!srcFiles || !universalizers[process.platform]) {
+        throw new Error(`'universal' arch for platform '${process.platform}' not supported.`);
+    }
+    debug(`Looking up source binaries to combine: `);
+    debug('  %O', srcFiles);
+    const srcFileLookup = await Promise.all(srcFiles.map((f) => fileExists(resolve(options.cwd, options.outputDir, f))));
+    const notFoundFiles = srcFiles.filter((_, i) => !srcFileLookup[i]);
+    if (notFoundFiles.length) {
+        throw new Error(`Some binary files were not found: ${JSON.stringify(notFoundFiles)}`);
+    }
+    const output = resolve(options.cwd, options.outputDir, `${config.binaryName}.${process.platform}-universal.node`);
+    universalizers[process.platform]?.(srcFiles, output);
+    debug(`Produced universal binary: ${output}`);
+}

package/dist/api/version.d.ts

@@ -0,0 +1,2 @@
+import { VersionOptions } from '../def/version.js';
+export declare function version(userOptions: VersionOptions): Promise<void>;

package/dist/api/version.js

@@ -0,0 +1,16 @@
+import { join, resolve } from 'path';
+import { applyDefaultVersionOptions } from '../def/version.js';
+import { readNapiConfig, debugFactory, updatePackageJson, } from '../utils/index.js';
+const debug = debugFactory('version');
+export async function version(userOptions) {
+    const options = applyDefaultVersionOptions(userOptions);
+    const packageJsonPath = resolve(options.cwd, options.packageJsonPath);
+    const config = await readNapiConfig(packageJsonPath);
+    for (const target of config.targets) {
+        const pkgDir = resolve(options.cwd, options.npmDir, target.platformArchABI);
+        debug(`Update version to %i in [%i]`, config.packageJson.version, pkgDir);
+        await updatePackageJson(join(pkgDir, 'package.json'), {
+            version: config.packageJson.version,
+        });
+    }
+}

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,25 @@
+import { Cli } from 'clipanion';
+import { ArtifactsCommand } from './commands/artifacts.js';
+import { BuildCommand } from './commands/build.js';
+import { CreateNpmDirsCommand } from './commands/create-npm-dirs.js';
+import { HelpCommand } from './commands/help.js';
+import { NewCommand } from './commands/new.js';
+import { PrePublishCommand } from './commands/pre-publish.js';
+import { RenameCommand } from './commands/rename.js';
+import { UniversalizeCommand } from './commands/universalize.js';
+import { VersionCommand } from './commands/version.js';
+import { CLI_VERSION } from './utils/misc.js';
+const cli = new Cli({
+    binaryName: 'napi',
+    binaryVersion: CLI_VERSION,
+});
+cli.register(NewCommand);
+cli.register(BuildCommand);
+cli.register(CreateNpmDirsCommand);
+cli.register(ArtifactsCommand);
+cli.register(UniversalizeCommand);
+cli.register(RenameCommand);
+cli.register(PrePublishCommand);
+cli.register(VersionCommand);
+cli.register(HelpCommand);
+void cli.runExit(process.argv.slice(2));

package/dist/commands/artifacts.d.ts

@@ -0,0 +1,6 @@
+import { BaseArtifactsCommand } from '../def/artifacts.js';
+export declare class ArtifactsCommand extends BaseArtifactsCommand {
+    static usage: import("clipanion").Usage;
+    static paths: string[][];
+    execute(): Promise<void>;
+}

package/dist/commands/artifacts.js

@@ -0,0 +1,19 @@
+import { Command } from 'clipanion';
+import { collectArtifacts } from '../api/artifacts.js';
+import { BaseArtifactsCommand } from '../def/artifacts.js';
+export class ArtifactsCommand extends BaseArtifactsCommand {
+    static usage = Command.Usage({
+        description: 'Copy artifacts from Github Actions into specified dir',
+        examples: [
+            [
+                '$0 artifacts --dir . --dist ./npm',
+                `Copy [binaryName].[platform].node under current dir(.) into packages under npm dir.
+e.g: index.linux-x64-gnu.node --> ./npm/linux-x64-gnu/index.node`,
+            ],
+        ],
+    });
+    static paths = [['artifacts']];
+    async execute() {
+        await collectArtifacts(this.getOptions());
+    }
+}

package/dist/commands/build.d.ts

@@ -0,0 +1,6 @@
+import { BaseBuildCommand } from '../def/build.js';
+export declare class BuildCommand extends BaseBuildCommand {
+    pipe: string | undefined;
+    cargoOptions: string[];
+    execute(): Promise<void>;
+}

package/dist/commands/build.js

@@ -0,0 +1,34 @@
+import { execSync } from 'child_process';
+import { Option } from 'clipanion';
+import { buildProject } from '../api/build.js';
+import { BaseBuildCommand } from '../def/build.js';
+import { debugFactory } from '../utils/index.js';
+const debug = debugFactory('build');
+export class BuildCommand extends BaseBuildCommand {
+    pipe = Option.String('--pipe', {
+        description: 'Pipe all outputs file to given command. e.g. `napi build --pipe "npx prettier --write"`',
+    });
+    cargoOptions = Option.Rest();
+    async execute() {
+        const { task } = await buildProject({
+            ...this.getOptions(),
+            cargoOptions: this.cargoOptions,
+        });
+        const outputs = await task;
+        if (this.pipe) {
+            for (const output of outputs) {
+                debug('Piping output file to command: %s', this.pipe);
+                try {
+                    execSync(`${this.pipe} ${output.path}`, {
+                        stdio: 'inherit',
+                        cwd: this.cwd,
+                    });
+                }
+                catch (e) {
+                    debug.error(`Failed to pipe output file ${output.path} to command`);
+                    debug.error(e);
+                }
+            }
+        }
+    }
+}

package/dist/commands/create-npm-dirs.d.ts

@@ -0,0 +1,4 @@
+import { BaseCreateNpmDirsCommand } from '../def/create-npm-dirs.js';
+export declare class CreateNpmDirsCommand extends BaseCreateNpmDirsCommand {
+    execute(): Promise<void>;
+}

package/dist/commands/create-npm-dirs.js

@@ -0,0 +1,7 @@
+import { createNpmDirs } from '../api/create-npm-dirs.js';
+import { BaseCreateNpmDirsCommand } from '../def/create-npm-dirs.js';
+export class CreateNpmDirsCommand extends BaseCreateNpmDirsCommand {
+    async execute() {
+        await createNpmDirs(this.getOptions());
+    }
+}

package/dist/commands/help.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'clipanion';
+/**
+ * A command that prints the usage of all commands.
+ *
+ * Paths: `-h`, `--help`
+ */
+export declare class HelpCommand extends Command<any> {
+    static paths: string[][];
+    execute(): Promise<void>;
+}

package/dist/commands/help.js

@@ -0,0 +1,12 @@
+import { Command } from 'clipanion';
+/**
+ * A command that prints the usage of all commands.
+ *
+ * Paths: `-h`, `--help`
+ */
+export class HelpCommand extends Command {
+    static paths = [[`-h`], [`--help`]];
+    async execute() {
+        await this.context.stdout.write(this.cli.usage());
+    }
+}

package/dist/commands/new.d.ts

@@ -0,0 +1,12 @@
+import { BaseNewCommand } from '../def/new.js';
+export declare class NewCommand extends BaseNewCommand {
+    interactive: boolean;
+    execute(): Promise<0 | 1>;
+    private fetchOptions;
+    private fetchName;
+    private fetchLicense;
+    private fetchNapiVersion;
+    private fetchTargets;
+    private fetchTypeDef;
+    private fetchGithubActions;
+}

package/dist/commands/new.js

@@ -0,0 +1,112 @@
+import path from 'path';
+import { Option } from 'clipanion';
+import inquirer from 'inquirer';
+import { newProject } from '../api/new.js';
+import { BaseNewCommand } from '../def/new.js';
+import { AVAILABLE_TARGETS, debugFactory, DEFAULT_TARGETS, } from '../utils/index.js';
+import { napiEngineRequirement } from '../utils/version.js';
+const debug = debugFactory('new');
+export class NewCommand extends BaseNewCommand {
+    interactive = Option.Boolean('--interactive,-i', false, {
+        description: 'Ask project basic information interactively without just using the default.',
+    });
+    async execute() {
+        try {
+            const options = await this.fetchOptions();
+            await newProject(options);
+            return 0;
+        }
+        catch (e) {
+            debug('Failed to create new project');
+            debug.error(e);
+            return 1;
+        }
+    }
+    async fetchOptions() {
+        const cmdOptions = super.getOptions();
+        if (this.interactive) {
+            return {
+                ...cmdOptions,
+                name: await this.fetchName(path.parse(cmdOptions.path).base),
+                minNodeApiVersion: await this.fetchNapiVersion(),
+                targets: await this.fetchTargets(),
+                license: await this.fetchLicense(),
+                enableTypeDef: await this.fetchTypeDef(),
+                enableGithubActions: await this.fetchGithubActions(),
+            };
+        }
+        return cmdOptions;
+    }
+    async fetchName(defaultName) {
+        return (this.$$name ??
+            (await inquirer
+                .prompt({
+                type: 'input',
+                name: 'name',
+                message: 'Package name (the name field in your package.json file)',
+                default: defaultName,
+            })
+                .then(({ name }) => name)));
+    }
+    async fetchLicense() {
+        return inquirer
+            .prompt({
+            type: 'input',
+            name: 'license',
+            message: 'License for open-sourced project',
+            default: this.license,
+        })
+            .then(({ license }) => license);
+    }
+    async fetchNapiVersion() {
+        return inquirer
+            .prompt({
+            type: 'list',
+            name: 'minNodeApiVersion',
+            message: 'Minimum node-api version (with node version requirement)',
+            loop: false,
+            choices: new Array(8).fill(0).map((_, i) => ({
+                name: `napi${i + 1} (${napiEngineRequirement(i + 1)})`,
+                value: i + 1,
+            })),
+            // choice index
+            default: this.minNodeApiVersion - 1,
+        })
+            .then(({ minNodeApiVersion }) => minNodeApiVersion);
+    }
+    async fetchTargets() {
+        if (this.enableDefaultTargets) {
+            return DEFAULT_TARGETS.concat();
+        }
+        if (this.enableAllTargets) {
+            return AVAILABLE_TARGETS.concat();
+        }
+        const { targets } = await inquirer.prompt({
+            name: 'targets',
+            type: 'checkbox',
+            loop: false,
+            message: 'Choose target(s) your crate will be compiled to',
+            default: DEFAULT_TARGETS,
+            choices: AVAILABLE_TARGETS,
+        });
+        return targets;
+    }
+    async fetchTypeDef() {
+        const { enableTypeDef } = await inquirer.prompt({
+            name: 'enableTypeDef',
+            type: 'confirm',
+            message: 'Enable type definition auto-generation',
+            default: this.enableTypeDef,
+        });
+        return enableTypeDef;
+    }
+    async fetchGithubActions() {
+        const { enableGithubActions } = await inquirer.prompt({
+            name: 'enableGithubActions',
+            type: 'confirm',
+            message: 'Enable Github Actions CI',
+            default: this.enableGithubActions,
+        });
+        return enableGithubActions;
+    }
+}

package/dist/commands/pre-publish.d.ts

@@ -0,0 +1,4 @@
+import { BasePrePublishCommand } from '../def/pre-publish.js';
+export declare class PrePublishCommand extends BasePrePublishCommand {
+    execute(): Promise<void>;
+}

package/dist/commands/pre-publish.js

@@ -0,0 +1,8 @@
+import { prePublish } from '../api/pre-publish.js';
+import { BasePrePublishCommand } from '../def/pre-publish.js';
+export class PrePublishCommand extends BasePrePublishCommand {
+    async execute() {
+        // @ts-expect-error const 'npm' | 'lerna' to string
+        await prePublish(this.getOptions());
+    }
+}

package/dist/commands/rename.d.ts

@@ -0,0 +1,4 @@
+import { BaseRenameCommand } from '../def/rename.js';
+export declare class RenameCommand extends BaseRenameCommand {
+    execute(): Promise<void>;
+}

package/dist/commands/rename.js

@@ -0,0 +1,7 @@
+import { renameProject } from '../api/rename.js';
+import { BaseRenameCommand } from '../def/rename.js';
+export class RenameCommand extends BaseRenameCommand {
+    async execute() {
+        await renameProject(this.getOptions());
+    }
+}

package/dist/commands/universalize.d.ts

@@ -0,0 +1,4 @@
+import { BaseUniversalizeCommand } from '../def/universalize.js';
+export declare class UniversalizeCommand extends BaseUniversalizeCommand {
+    execute(): Promise<void>;
+}

package/dist/commands/universalize.js

@@ -0,0 +1,7 @@
+import { universalizeBinaries } from '../api/universalize.js';
+import { BaseUniversalizeCommand } from '../def/universalize.js';
+export class UniversalizeCommand extends BaseUniversalizeCommand {
+    async execute() {
+        await universalizeBinaries(this.getOptions());
+    }
+}

package/dist/commands/version.d.ts

@@ -0,0 +1,4 @@
+import { BaseVersionCommand } from '../def/version.js';
+export declare class VersionCommand extends BaseVersionCommand {
+    execute(): Promise<void>;
+}

package/dist/commands/version.js

@@ -0,0 +1,7 @@
+import { version } from '../api/version.js';
+import { BaseVersionCommand } from '../def/version.js';
+export class VersionCommand extends BaseVersionCommand {
+    async execute() {
+        await version(this.getOptions());
+    }
+}

package/dist/def/artifacts.d.ts

@@ -0,0 +1,50 @@
+import { Command } from 'clipanion';
+export declare abstract class BaseArtifactsCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    cwd: string;
+    packageJsonPath: string;
+    outputDir: string;
+    npmDir: string;
+    getOptions(): {
+        cwd: string;
+        packageJsonPath: string;
+        outputDir: string;
+        npmDir: string;
+    };
+}
+/**
+ * Copy artifacts from Github Actions into npm packages and ready to publish
+ */
+export 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 `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;
+    /**
+     * Path to the folder where the npm packages put
+     *
+     * @default 'npm'
+     */
+    npmDir?: string;
+}
+export declare function applyDefaultArtifactsOptions(options: ArtifactsOptions): {
+    cwd: string;
+    packageJsonPath: string;
+    outputDir: string;
+    npmDir: string;
+};

package/dist/def/artifacts.js

@@ -0,0 +1,38 @@
+// This file is generated by codegen/index.ts
+// Do not edit this file manually
+import { Command, Option } from 'clipanion';
+export class BaseArtifactsCommand extends Command {
+    static paths = [['artifacts']];
+    static usage = Command.Usage({
+        description: 'Copy artifacts from Github Actions into npm packages and ready to publish',
+    });
+    cwd = Option.String('--cwd', process.cwd(), {
+        description: 'The working directory of where napi command will be executed in, all other paths options are relative to this path',
+    });
+    packageJsonPath = Option.String('--package-json-path', 'package.json', {
+        description: 'Path to `package.json`',
+    });
+    outputDir = Option.String('--output-dir,-o', './', {
+        description: 'Path to the folder where all built `.node` files put, same as `--output-dir` of build command',
+    });
+    npmDir = Option.String('--npm-dir', 'npm', {
+        description: 'Path to the folder where the npm packages put',
+    });
+    getOptions() {
+        return {
+            cwd: this.cwd,
+            packageJsonPath: this.packageJsonPath,
+            outputDir: this.outputDir,
+            npmDir: this.npmDir,
+        };
+    }
+}
+export function applyDefaultArtifactsOptions(options) {
+    return {
+        cwd: process.cwd(),
+        packageJsonPath: 'package.json',
+        outputDir: './',
+        npmDir: 'npm',
+        ...options,
+    };
+}