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

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

@@ -1,37 +0,0 @@
-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.js

@@ -1,5 +0,0 @@
-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.js

@@ -1,33 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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.js

@@ -1,42 +0,0 @@
-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.js

@@ -1,9 +0,0 @@
-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.js

@@ -1,14 +0,0 @@
-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.js

@@ -1,19 +0,0 @@
-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.js

@@ -1,35 +0,0 @@
-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.js

@@ -1,109 +0,0 @@
-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.js

@@ -1,158 +0,0 @@
-import { sortBy } from 'lodash-es';
-import { readFileAsync } from './misc.js';
-const TOP_LEVEL_NAMESPACE = '__TOP_LEVEL_MODULE__';
-export const DEFAULT_TYPE_DEF_HEADER = `/* auto-generated by NAPI-RS */
-/* eslint-disable */
-`;
-var TypeDefKind;
-(function (TypeDefKind) {
-    TypeDefKind["Const"] = "const";
-    TypeDefKind["Enum"] = "enum";
-    TypeDefKind["Interface"] = "interface";
-    TypeDefKind["Fn"] = "fn";
-    TypeDefKind["Struct"] = "struct";
-    TypeDefKind["Impl"] = "impl";
-})(TypeDefKind || (TypeDefKind = {}));
-function prettyPrint(line, ident) {
-    let s = line.js_doc ?? '';
-    switch (line.kind) {
-        case TypeDefKind.Interface:
-            s += `export interface ${line.name} {\n${line.def}\n}`;
-            break;
-        case TypeDefKind.Enum:
-            s += `export const enum ${line.name} {\n${line.def}\n}`;
-            break;
-        case TypeDefKind.Struct:
-            s += `export class ${line.name} {\n${line.def}\n}`;
-            if (line.original_name && line.original_name !== line.name) {
-                s += `\nexport type ${line.original_name} = ${line.name}`;
-            }
-            break;
-        default:
-            s += line.def;
-    }
-    return correctStringIdent(s, ident);
-}
-export async function processTypeDef(intermediateTypeFile, header) {
-    const defs = await readIntermediateTypeFile(intermediateTypeFile);
-    const groupedDefs = preprocessTypeDef(defs);
-    header = header ? header + '\n' : '';
-    let dts = '';
-    sortBy(Array.from(groupedDefs), ([namespace]) => namespace).forEach(([namespace, defs]) => {
-        if (namespace === TOP_LEVEL_NAMESPACE) {
-            for (const def of defs) {
-                dts += prettyPrint(def, 0) + '\n\n';
-            }
-        }
-        else {
-            dts += `export namespace ${namespace} {\n`;
-            for (const def of defs) {
-                dts += prettyPrint(def, 2) + '\n';
-            }
-            dts += '}\n\n';
-        }
-    });
-    if (dts.indexOf('ExternalObject<') > -1) {
-        header += `
-export class ExternalObject<T> {
-  readonly '': {
-    readonly '': unique symbol
-    [K: symbol]: T
-  }
-}
-`;
-    }
-    return header + dts;
-}
-async function readIntermediateTypeFile(file) {
-    const content = await readFileAsync(file, 'utf8');
-    const defs = content
-        .split('\n')
-        .filter(Boolean)
-        .map((line) => {
-        line = line.trim();
-        if (!line.startsWith('{')) {
-            // crateName:{ "def": "", ... }
-            const start = line.indexOf(':') + 1;
-            line = line.slice(start);
-        }
-        return JSON.parse(line);
-    });
-    // move all `struct` def to the very top
-    // and order the rest alphabetically.
-    return defs.sort((a, b) => {
-        if (a.kind === TypeDefKind.Struct) {
-            if (b.kind === TypeDefKind.Struct) {
-                return a.name.localeCompare(b.name);
-            }
-            return -1;
-        }
-        else if (b.kind === TypeDefKind.Struct) {
-            return 1;
-        }
-        else {
-            return a.name.localeCompare(b.name);
-        }
-    });
-}
-function preprocessTypeDef(defs) {
-    const namespaceGrouped = new Map();
-    const classDefs = new Map();
-    for (const def of defs) {
-        const namespace = def.js_mod ?? TOP_LEVEL_NAMESPACE;
-        if (!namespaceGrouped.has(namespace)) {
-            namespaceGrouped.set(namespace, []);
-        }
-        const group = namespaceGrouped.get(namespace);
-        if (def.kind === TypeDefKind.Struct) {
-            group.push(def);
-            classDefs.set(def.name, def);
-        }
-        else if (def.kind === TypeDefKind.Impl) {
-            // merge `impl` into class definition
-            const classDef = classDefs.get(def.name);
-            if (classDef) {
-                if (classDef.def) {
-                    classDef.def += '\n';
-                }
-                classDef.def += def.def;
-            }
-        }
-        else {
-            group.push(def);
-        }
-    }
-    return namespaceGrouped;
-}
-export function correctStringIdent(src, ident) {
-    let bracketDepth = 0;
-    const result = src
-        .split('\n')
-        .map((line) => {
-        line = line.trim();
-        if (line === '') {
-            return '';
-        }
-        const isInMultilineComment = line.startsWith('*');
-        const isClosingBracket = line.endsWith('}');
-        const isOpeningBracket = line.endsWith('{');
-        let rightIndent = ident;
-        if (isOpeningBracket && !isInMultilineComment) {
-            bracketDepth += 1;
-            rightIndent += (bracketDepth - 1) * 2;
-        }
-        else {
-            if (isClosingBracket && bracketDepth > 0 && !isInMultilineComment) {
-                bracketDepth -= 1;
-            }
-            rightIndent += bracketDepth * 2;
-        }
-        if (isInMultilineComment) {
-            rightIndent += 1;
-        }
-        const s = `${' '.repeat(rightIndent)}${line}`;
-        return s;
-    })
-        .join('\n');
-    return result;
-}

package/dist/utils/version.js

@@ -1,59 +0,0 @@
-export var NapiVersion;
-(function (NapiVersion) {
-    NapiVersion[NapiVersion["Napi1"] = 1] = "Napi1";
-    NapiVersion[NapiVersion["Napi2"] = 2] = "Napi2";
-    NapiVersion[NapiVersion["Napi3"] = 3] = "Napi3";
-    NapiVersion[NapiVersion["Napi4"] = 4] = "Napi4";
-    NapiVersion[NapiVersion["Napi5"] = 5] = "Napi5";
-    NapiVersion[NapiVersion["Napi6"] = 6] = "Napi6";
-    NapiVersion[NapiVersion["Napi7"] = 7] = "Napi7";
-    NapiVersion[NapiVersion["Napi8"] = 8] = "Napi8";
-})(NapiVersion = NapiVersion || (NapiVersion = {}));
-/// because node support new napi version in some minor version updates, so we might meet such situation:
-/// `node v10.20.0` supports `napi5` and `napi6`, but `node v12.0.0` only support `napi4`,
-/// by which, we can not tell directly napi version supportness from node version directly.
-const NAPI_VERSION_MATRIX = new Map([
-    [NapiVersion.Napi1, '8.6.0'],
-    [NapiVersion.Napi2, '8.10.0 | 9.3.0'],
-    [NapiVersion.Napi3, '6.14.2 | 8.11.2 | 9.11.0'],
-    [NapiVersion.Napi4, '10.16.0 | 11.8.0'],
-    [NapiVersion.Napi5, '10.17.0 | 12.11.0'],
-    [NapiVersion.Napi6, '10.20.0 | 12.17.0 | 14.0.0'],
-    [NapiVersion.Napi7, '10.23.0 | 12.19.0 | 14.12.0'],
-    [NapiVersion.Napi8, '12.22.0 | 14.17.0 | 15.12.0'],
-]);
-function parseNodeVersion(v) {
-    const matches = v.match(/v?([0-9]+)\.([0-9]+)\.([0-9]+)/i);
-    if (!matches) {
-        throw new Error('Unknown node version number: ' + v);
-    }
-    const [, major, minor, patch] = matches;
-    return {
-        major: parseInt(major),
-        minor: parseInt(minor),
-        patch: parseInt(patch),
-    };
-}
-function requiredNodeVersions(napiVersion) {
-    const requirement = NAPI_VERSION_MATRIX.get(napiVersion);
-    if (!requirement) {
-        return [parseNodeVersion('10.0.0')];
-    }
-    return requirement.split('|').map(parseNodeVersion);
-}
-function toEngineRequirement(versions) {
-    const requirements = [];
-    versions.forEach((v, i) => {
-        let req = '';
-        if (i !== 0) {
-            const lastVersion = versions[i - 1];
-            req += `< ${lastVersion.major + 1}`;
-        }
-        req += `${i === 0 ? '' : ' || '}>= ${v.major}.${v.minor}.${v.patch}`;
-        requirements.push(req);
-    });
-    return requirements.join(' && ');
-}
-export function napiEngineRequirement(napiVersion) {
-    return toEngineRequirement(requiredNodeVersions(napiVersion));
-}