@napi-rs/cli 3.0.0-alpha.1 → 3.0.0-alpha.100

package/dist/api/build.js

@@ -1,404 +0,0 @@
-import { spawn } from 'child_process';
-import { createHash } from 'crypto';
-import { tmpdir } from 'os';
-import { parse, join, resolve } from 'path';
-import * as colors from 'colorette';
-import { CLI_VERSION, copyFileAsync, debugFactory, DEFAULT_TYPE_DEF_HEADER, fileExists, getSystemDefaultTarget, getTargetLinker, mkdirAsync, parseMetadata, parseTriple, processTypeDef, readNapiConfig, targetToEnvVar, tryInstallCargoBinary, unlinkAsync, writeFileAsync, } from '../utils/index.js';
-import { createJsBinding } from './templates/index.js';
-const debug = debugFactory('build');
-export async function buildProject(options) {
-    debug('napi build command receive options: %O', options);
-    const cwd = options.cwd ?? process.cwd();
-    const resolvePath = (...paths) => resolve(cwd, ...paths);
-    const manifestPath = resolvePath(options.manifestPath ?? 'Cargo.toml');
-    const metadata = parseMetadata(manifestPath);
-    const pkg = metadata.packages.find((p) => {
-        // package with given name
-        if (options.package) {
-            return p.name === options.package;
-        }
-        else {
-            return p.manifest_path === manifestPath;
-        }
-    });
-    if (!pkg) {
-        throw new Error('Unable to find crate to build. It seems you are trying to build a crate in a workspace, try using `--package` option to specify the package to build.');
-    }
-    const crateDir = parse(pkg.manifest_path).dir;
-    const builder = new Builder(options, pkg, cwd, options.target
-        ? parseTriple(options.target)
-        : process.env.CARGO_BUILD_TARGET
-            ? parseTriple(process.env.CARGO_BUILD_TARGET)
-            : getSystemDefaultTarget(), crateDir, resolvePath(options.outputDir ?? crateDir), options.targetDir ??
-        process.env.CARGO_BUILD_TARGET_DIR ??
-        metadata.target_directory, await readNapiConfig(resolvePath(options.packageJsonPath ?? 'package.json')));
-    return builder.build();
-}
-class Builder {
-    options;
-    crate;
-    cwd;
-    target;
-    crateDir;
-    outputDir;
-    targetDir;
-    config;
-    args = [];
-    envs = {};
-    outputs = [];
-    constructor(options, crate, cwd, target, crateDir, outputDir, targetDir, config) {
-        this.options = options;
-        this.crate = crate;
-        this.cwd = cwd;
-        this.target = target;
-        this.crateDir = crateDir;
-        this.outputDir = outputDir;
-        this.targetDir = targetDir;
-        this.config = config;
-    }
-    get cdyLibName() {
-        return this.crate.targets.find((t) => t.crate_types.includes('cdylib'))
-            ?.name;
-    }
-    get binName() {
-        return (this.options.bin ??
-            // only available if not cdylib or bin name specified
-            (this.cdyLibName
-                ? null
-                : this.crate.targets.find((t) => t.crate_types.includes('bin'))?.name));
-    }
-    build() {
-        if (!this.cdyLibName) {
-            const warning = 'Missing `crate-type = ["cdylib"]` in [lib] config. The build result will not be available as node addon.';
-            if (this.binName) {
-                debug.warn(warning);
-            }
-            else {
-                throw new Error(warning);
-            }
-        }
-        return this.pickBinary()
-            .setPackage()
-            .setFeatures()
-            .setTarget()
-            .setEnvs()
-            .setBypassArgs()
-            .exec();
-    }
-    exec() {
-        debug(`Start building crate: ${this.crate.name}`);
-        debug('  %i', `cargo ${this.args.join(' ')}`);
-        const controller = new AbortController();
-        const buildTask = new Promise((resolve, reject) => {
-            const buildProcess = spawn('cargo', this.args, {
-                env: {
-                    ...process.env,
-                    ...this.envs,
-                },
-                stdio: 'inherit',
-                cwd: this.cwd,
-                signal: controller.signal,
-            });
-            buildProcess.once('exit', (code) => {
-                if (code === 0) {
-                    debug('%i', `Build crate ${this.crate.name} successfully!`);
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Build failed with exit code ${code}`));
-                }
-            });
-            buildProcess.once('error', (e) => {
-                reject(new Error(`Build failed with error: ${e.message}`, {
-                    cause: e,
-                }));
-            });
-        });
-        return {
-            task: buildTask.then(() => this.postBuild()),
-            abort: () => controller.abort(),
-        };
-    }
-    pickBinary() {
-        let set = false;
-        if (this.options.watch) {
-            if (process.env.CI) {
-                debug.warn('Watch mode is not supported in CI environment');
-            }
-            else {
-                debug('Use %i', 'cargo-watch');
-                tryInstallCargoBinary('cargo-watch', 'watch');
-                // yarn napi watch --target x86_64-unknown-linux-gnu [--cross-compile]
-                // ===>
-                // cargo watch [...] -- build --target x86_64-unknown-linux-gnu
-                // cargo watch [...] -- zigbuild --target x86_64-unknown-linux-gnu
-                this.args.push('watch', '--why', '-i', '*.{js,ts,node}', '-w', this.crateDir, '--', 'cargo');
-                set = true;
-            }
-        }
-        if (this.options.crossCompile) {
-            if (this.target.platform === 'win32') {
-                if (process.platform === 'win32') {
-                    debug.warn('You are trying to cross compile to win32 platform on win32 platform which is unnecessary.');
-                }
-                else {
-                    // use cargo-xwin to cross compile to win32 platform
-                    debug('Use %i', 'cargo-xwin');
-                    tryInstallCargoBinary('cargo-xwin', 'xwin');
-                    this.args.push('xwin', 'build');
-                    if (this.target.arch === 'ia32') {
-                        this.envs.XWIN_ARCH = 'x86';
-                    }
-                    set = true;
-                }
-            }
-            else {
-                if (this.target.platform === 'linux' &&
-                    process.platform === 'linux' &&
-                    this.target.arch === process.arch &&
-                    (function (abi) {
-                        const glibcVersionRuntime = 
-                        // @ts-expect-error
-                        process.report?.getReport()?.header?.glibcVersionRuntime;
-                        const libc = glibcVersionRuntime ? 'gnu' : 'musl';
-                        return abi === libc;
-                    })(this.target.abi)) {
-                    debug.warn('You are trying to cross compile to linux target on linux platform which is unnecessary.');
-                }
-                else if (this.target.platform === 'darwin' &&
-                    process.platform === 'darwin') {
-                    debug.warn('You are trying to cross compile to darwin target on darwin platform which is unnecessary.');
-                }
-                else {
-                    // use cargo-zigbuild to cross compile to other platforms
-                    debug('Use %i', 'cargo-zigbuild');
-                    tryInstallCargoBinary('cargo-zigbuild', 'zigbuild');
-                    this.args.push('zigbuild');
-                    set = true;
-                }
-            }
-        }
-        if (!set) {
-            this.args.push('build');
-        }
-        return this;
-    }
-    setPackage() {
-        const args = [];
-        if (this.options.package) {
-            args.push('--package', this.options.package);
-        }
-        if (this.binName) {
-            args.push('--bin', this.binName);
-        }
-        if (args.length) {
-            debug('Set package flags: ');
-            debug('  %O', args);
-            this.args.push(...args);
-        }
-        return this;
-    }
-    setTarget() {
-        debug('Set compiling target to: ');
-        debug('  %i', this.target.triple);
-        this.args.push('--target', this.target.triple);
-        return this;
-    }
-    setEnvs() {
-        // type definition intermediate file
-        this.envs.TYPE_DEF_TMP_PATH = this.getIntermediateTypeFile();
-        this.envs.CARGO_CFG_NAPI_RS_CLI_VERSION = CLI_VERSION;
-        // RUSTFLAGS
-        let rustflags = process.env.RUSTFLAGS ?? process.env.CARGO_BUILD_RUSTFLAGS ?? '';
-        if (this.target.abi?.includes('musl') &&
-            !rustflags.includes('target-feature=-crt-static')) {
-            rustflags += ' -C target-feature=-crt-static';
-        }
-        if (this.options.strip && !rustflags.includes('link-arg=-s')) {
-            rustflags += ' -C link-arg=-s';
-        }
-        if (rustflags.length) {
-            this.envs.RUSTFLAGS = rustflags;
-        }
-        // END RUSTFLAGS
-        // LINKER
-        const linker = getTargetLinker(this.target.triple);
-        if (linker &&
-            !process.env.RUSTC_LINKER &&
-            !process.env[`CARGET_TARGET_${targetToEnvVar(this.target.triple)}_LINKER`]) {
-            this.envs.RUSTC_LINKER = linker;
-        }
-        if (this.target.platform === 'android') {
-            const { ANDROID_NDK_LATEST_HOME } = process.env;
-            if (!ANDROID_NDK_LATEST_HOME) {
-                debug.warn(`${colors.red('ANDROID_NDK_LATEST_HOME')} environment variable is missing`);
-            }
-            const targetArch = this.target.arch === 'arm' ? 'armv7a' : 'aarch64';
-            const targetPlatform = this.target.arch === 'arm' ? 'androideabi24' : 'android24';
-            Object.assign(this.envs, {
-                CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-android24-clang`,
-                CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
-                CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
-                CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
-                AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar`,
-                ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
-                PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${process.env.PATH}`,
-            });
-        }
-        // END LINKER
-        debug('Set envs: ');
-        Object.entries(this.envs).forEach(([k, v]) => {
-            debug('  %i', `${k}=${v}`);
-        });
-        return this;
-    }
-    setFeatures() {
-        const args = [];
-        if (this.options.allFeatures) {
-            args.push('--all-features');
-        }
-        else if (this.options.noDefaultFeatures) {
-            args.push('--no-default-features');
-        }
-        else if (this.options.features) {
-            args.push('--features', ...this.options.features);
-        }
-        debug('Set features flags: ');
-        debug('  %O', args);
-        this.args.push(...args);
-        return this;
-    }
-    setBypassArgs() {
-        if (this.options.release) {
-            this.args.push('--release');
-        }
-        if (this.options.verbose) {
-            this.args.push('--verbose');
-        }
-        if (this.options.targetDir) {
-            this.args.push('--target-dir', this.options.targetDir);
-        }
-        if (this.options.cargoOptions?.length) {
-            this.args.push(...this.options.cargoOptions);
-        }
-        return this;
-    }
-    getIntermediateTypeFile() {
-        return join(tmpdir(), `${this.crate.name}-${createHash('sha256')
-            .update(this.crate.manifest_path)
-            .update(CLI_VERSION)
-            .digest('hex')
-            .substring(0, 8)}.napi_type_def.tmp`);
-    }
-    async postBuild() {
-        try {
-            debug(`Try to create output directory:`);
-            debug('  %i', this.outputDir);
-            await mkdirAsync(this.outputDir, { recursive: true });
-            debug(`Output directory created`);
-        }
-        catch (e) {
-            throw new Error(`Failed to create output directory ${this.outputDir}`, {
-                cause: e,
-            });
-        }
-        await this.copyArtifact();
-        // only for cdylib
-        if (this.cdyLibName) {
-            await this.generateTypeDef();
-            await this.writeJsBinding();
-        }
-        return this.outputs;
-    }
-    async copyArtifact() {
-        const [srcName, destName] = this.getArtifactNames();
-        if (!srcName || !destName) {
-            return;
-        }
-        const src = join(this.targetDir, this.target.triple, this.options.release ? 'release' : 'debug', srcName);
-        const dest = join(this.outputDir, destName);
-        try {
-            if (await fileExists(dest)) {
-                debug('Old artifact found, remove it first');
-                await unlinkAsync(dest);
-            }
-            debug('Copy artifact to:');
-            debug('  %i', dest);
-            await copyFileAsync(src, dest);
-            this.outputs.push({
-                kind: dest.endsWith('.node') ? 'node' : 'exe',
-                path: dest,
-            });
-        }
-        catch (e) {
-            throw new Error('Failed to copy artifact', {
-                cause: e,
-            });
-        }
-    }
-    getArtifactNames() {
-        if (this.cdyLibName) {
-            const cdyLib = this.cdyLibName.replace(/-/g, '_');
-            const srcName = this.target.platform === 'darwin'
-                ? `lib${cdyLib}.dylib`
-                : this.target.platform === 'win32'
-                    ? `${cdyLib}.dll`
-                    : `lib${cdyLib}.so`;
-            let destName = this.config.binaryName;
-            // add platform suffix to binary name
-            // index[.linux-x64-gnu].node
-            //       ^^^^^^^^^^^^^^
-            if (this.options.platform) {
-                destName += `.${this.target.platformArchABI}`;
-            }
-            destName += '.node';
-            return [srcName, destName];
-        }
-        else if (this.binName) {
-            const srcName = this.target.platform === 'win32' ? `${this.binName}.exe` : this.binName;
-            return [srcName, srcName];
-        }
-        return [];
-    }
-    async generateTypeDef() {
-        if (!(await fileExists(this.envs.TYPE_DEF_TMP_PATH))) {
-            return;
-        }
-        const dest = join(this.outputDir, this.options.dts ?? 'index.d.ts');
-        const dts = await processTypeDef(this.envs.TYPE_DEF_TMP_PATH, !this.options.noDtsHeader
-            ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
-            : '');
-        try {
-            debug('Writing type def to:');
-            debug('  %i', dest);
-            await writeFileAsync(dest, dts, 'utf-8');
-            this.outputs.push({
-                kind: 'dts',
-                path: dest,
-            });
-        }
-        catch (e) {
-            debug.error('Failed to write type def file');
-            debug.error(e);
-        }
-    }
-    async writeJsBinding() {
-        if (!this.options.platform || this.options.noJsBinding) {
-            return;
-        }
-        const dest = join(this.outputDir, this.options.jsBinding ?? 'index.js');
-        const js = createJsBinding(this.config.binaryName, this.config.packageName);
-        try {
-            debug('Writing js binding to:');
-            debug('  %i', dest);
-            await writeFileAsync(dest, js, 'utf-8');
-            this.outputs.push({
-                kind: 'js',
-                path: dest,
-            });
-        }
-        catch (e) {
-            throw new Error('Failed to write js binding file', { cause: e });
-        }
-    }
-}

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

@@ -1,63 +0,0 @@
-import { join, resolve } from 'path';
-import { applyDefaultCreateNpmDirsOptions, } from '../def/create-npm-dirs.js';
-import { debugFactory, readNapiConfig, mkdirAsync as rawMkdirAsync, pick, writeFileAsync as rawWriteFileAsync, } from '../utils/index.js';
-const debug = debugFactory('create-npm-dirs');
-export async function createNpmDirs(userOptions) {
-    const options = applyDefaultCreateNpmDirsOptions(userOptions);
-    async function mkdirAsync(dir) {
-        debug('Try to create dir: %i', dir);
-        if (options.dryRun) {
-            return;
-        }
-        await rawMkdirAsync(dir, {
-            recursive: true,
-        });
-    }
-    async function writeFileAsync(file, content) {
-        debug('Writing file %i', file);
-        if (options.dryRun) {
-            debug(content);
-            return;
-        }
-        await rawWriteFileAsync(file, content);
-    }
-    const packageJsonPath = resolve(options.cwd, options.packageJsonPath);
-    const npmPath = resolve(options.cwd, options.npmDir);
-    debug(`Read content from [${packageJsonPath}]`);
-    const { targets, binaryName, packageName, packageJson } = await readNapiConfig(packageJsonPath);
-    for (const target of targets) {
-        const targetDir = join(npmPath, `${target.platformArchABI}`);
-        await mkdirAsync(targetDir);
-        const binaryFileName = `${binaryName}.${target.platformArchABI}.node`;
-        const scopedPackageJson = {
-            name: `${packageName}-${target.platformArchABI}`,
-            version: packageJson.version,
-            os: [target.platform],
-            cpu: target.arch !== 'universal' ? [target.arch] : undefined,
-            main: binaryFileName,
-            files: [binaryFileName],
-            ...pick(packageJson, 'description', 'keywords', 'author', 'authors', 'homepage', 'license', 'engines', 'publishConfig', 'repository', 'bugs'),
-        };
-        // Only works with yarn 3.1+
-        // https://github.com/yarnpkg/berry/pull/3981
-        if (target.abi === 'gnu') {
-            // @ts-expect-error
-            scopedPackageJson.libc = ['glibc'];
-        }
-        else if (target.abi === 'musl') {
-            // @ts-expect-error
-            scopedPackageJson.libc = ['musl'];
-        }
-        const targetPackageJson = join(targetDir, 'package.json');
-        await writeFileAsync(targetPackageJson, JSON.stringify(scopedPackageJson, null, 2));
-        const targetReadme = join(targetDir, 'README.md');
-        await writeFileAsync(targetReadme, readme(packageName, target));
-        debug.info(`${packageName}-${target.platformArchABI} created`);
-    }
-}
-function readme(packageName, target) {
-    return `# \`${packageName}-${target.platformArchABI}\`
-
-This is the **${target.triple}** binary for \`${packageName}\`
-`;
-}

package/dist/api/new.js

@@ -1,154 +0,0 @@
-import path from 'path';
-import { applyDefaultNewOptions, } from '../def/new.js';
-import { AVAILABLE_TARGETS, CLI_VERSION, debugFactory, DEFAULT_TARGETS, mkdirAsync, writeFileAsync, } from '../utils/index.js';
-import { napiEngineRequirement } from '../utils/version.js';
-import { createBuildRs, createCargoToml, createGithubActionsCIYml, createLibRs, createPackageJson, gitIgnore, npmIgnore, } from './templates/index.js';
-const debug = debugFactory('new');
-function processOptions(options) {
-    debug('Processing options...');
-    options.path = path.resolve(process.cwd(), options.path);
-    debug(`Resolved target path to: ${options.path}`);
-    if (!options.name) {
-        options.name = path.parse(options.path).base;
-        debug(`No project name provided, fix it to dir name: ${options.name}`);
-    }
-    if (!options.targets?.length) {
-        if (options.enableAllTargets) {
-            options.targets = AVAILABLE_TARGETS.concat();
-            debug('Enable all targets');
-        }
-        else if (options.enableDefaultTargets) {
-            options.targets = DEFAULT_TARGETS.concat();
-            debug('Enable default targets');
-        }
-        else {
-            throw new Error('At least one target must be enabled');
-        }
-    }
-    return applyDefaultNewOptions(options);
-}
-export async function newProject(userOptions) {
-    debug('Will create napi-rs project with given options:');
-    debug(userOptions);
-    const options = processOptions(userOptions);
-    debug('Targets to be enabled:');
-    debug(options.targets);
-    const outputs = generateFiles(options);
-    try {
-        debug(`Try to create target directory: ${options.path}`);
-        if (!options.dryRun) {
-            await mkdirAsync(options.path, { recursive: true });
-        }
-    }
-    catch (e) {
-        throw new Error(`Failed to create target directory: ${options.path}`, {
-            cause: e,
-        });
-    }
-    await dumpOutputs(outputs, options.dryRun);
-    debug(`Project created at: ${options.path}`);
-}
-function generateFiles(options) {
-    return [
-        generateCargoToml,
-        generateLibRs,
-        generateBuildRs,
-        generatePackageJson,
-        generateGithubWorkflow,
-        generateIgnoreFiles,
-    ].flatMap((generator) => {
-        const output = generator(options);
-        if (!output) {
-            return [];
-        }
-        if (Array.isArray(output)) {
-            return output.map((o) => ({
-                ...o,
-                target: path.join(options.path, o.target),
-            }));
-        }
-        else {
-            return [{ ...output, target: path.join(options.path, output.target) }];
-        }
-    });
-}
-function generateCargoToml(options) {
-    return {
-        target: './Cargo.toml',
-        content: createCargoToml({
-            name: options.name,
-            license: options.license,
-            features: [`napi${options.minNodeApiVersion}`],
-            deriveFeatures: options.enableTypeDef ? ['type-def'] : [],
-        }),
-    };
-}
-function generateLibRs(_options) {
-    return {
-        target: './src/lib.rs',
-        content: createLibRs(),
-    };
-}
-function generateBuildRs(_options) {
-    return {
-        target: './build.rs',
-        content: createBuildRs(),
-    };
-}
-function generatePackageJson(options) {
-    return {
-        target: './package.json',
-        content: createPackageJson({
-            name: options.name,
-            binaryName: getBinaryName(options.name),
-            targets: options.targets,
-            license: options.license,
-            engineRequirement: napiEngineRequirement(options.minNodeApiVersion),
-            cliVersion: CLI_VERSION,
-        }),
-    };
-}
-function generateGithubWorkflow(options) {
-    if (!options.enableGithubActions) {
-        return null;
-    }
-    return {
-        target: './.github/workflows/ci.yml',
-        content: createGithubActionsCIYml(getBinaryName(options.name), options.targets),
-    };
-}
-function generateIgnoreFiles(_options) {
-    return [
-        {
-            target: './.gitignore',
-            content: gitIgnore,
-        },
-        {
-            target: './.npmignore',
-            content: npmIgnore,
-        },
-    ];
-}
-async function dumpOutputs(outputs, dryRun) {
-    for (const output of outputs) {
-        if (!output) {
-            continue;
-        }
-        debug(`Writing project file: ${output.target}`);
-        // only output content to logger instead of writing to file system
-        if (dryRun) {
-            debug(output.content);
-            continue;
-        }
-        try {
-            await mkdirAsync(path.dirname(output.target), { recursive: true });
-            await writeFileAsync(output.target, output.content, 'utf-8');
-        }
-        catch (e) {
-            throw new Error(`Failed to write file: ${output.target}`, { cause: e });
-        }
-    }
-}
-function getBinaryName(name) {
-    return name.split('/').pop();
-}