@netlify/zip-it-and-ship-it 4.23.3 → 4.23.5-setup-typescript-4

package/dist/runtimes/rust/builder.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { readFile } = require('fs');
+const { basename, join } = require('path');
+const { promisify } = require('util');
+const pReadFile = promisify(readFile);
+const makeDir = require('make-dir');
+const tmp = require('tmp-promise');
+const toml = require('toml');
+const { RUNTIME_RUST } = require('../../utils/consts');
+const { lstat } = require('../../utils/fs');
+const { runCommand } = require('../../utils/shell');
+const { BUILD_TARGET, MANIFEST_NAME } = require('./constants');
+const build = ({ config, name, srcDir }) => __awaiter(this, void 0, void 0, function* () {
+    const functionName = basename(srcDir);
+    try {
+        yield installBuildTarget();
+    }
+    catch (error) {
+        error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_RUST } };
+        throw error;
+    }
+    const targetDirectory = yield getTargetDirectory({ config, name });
+    yield cargoBuild({ functionName, srcDir, targetDirectory });
+    // By default, the binary will have the same name as the crate and there's no
+    // way to override it (https://github.com/rust-lang/cargo/issues/1706). We
+    // must extract the crate name from the manifest and use it to form the path
+    // to the binary.
+    const manifest = yield pReadFile(join(srcDir, MANIFEST_NAME));
+    const { package } = toml.parse(manifest);
+    const binaryPath = join(targetDirectory, BUILD_TARGET, 'release', package.name);
+    const stat = yield lstat(binaryPath);
+    return {
+        path: binaryPath,
+        stat,
+    };
+});
+const cargoBuild = ({ functionName, srcDir, targetDirectory }) => __awaiter(this, void 0, void 0, function* () {
+    try {
+        yield runCommand('cargo', ['build', '--target', BUILD_TARGET, '--release'], {
+            cwd: srcDir,
+            env: {
+                CARGO_TARGET_DIR: targetDirectory,
+            },
+        });
+    }
+    catch (error) {
+        const hasToolchain = yield checkRustToolchain();
+        if (hasToolchain) {
+            console.error(`Could not compile Rust function ${functionName}:\n`);
+        }
+        else {
+            error.message =
+                'There is no Rust toolchain installed. Visit https://ntl.fyi/missing-rust-toolchain for more information.';
+        }
+        error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_RUST } };
+        throw error;
+    }
+});
+const checkRustToolchain = () => __awaiter(this, void 0, void 0, function* () {
+    try {
+        yield runCommand('cargo', ['-V']);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+});
+// Returns the path of the Cargo target directory.
+const getTargetDirectory = ({ config, name }) => __awaiter(this, void 0, void 0, function* () {
+    const { rustTargetDirectory } = config;
+    // If the config includes a `rustTargetDirectory` path, we'll use that.
+    if (rustTargetDirectory) {
+        // We replace the [name] placeholder with the name of the function.
+        const path = rustTargetDirectory.replace(/\[name]/g, name);
+        yield makeDir(path);
+        return path;
+    }
+    // If the directory hasn't been configured, we'll use a temporary directory.
+    const { path } = yield tmp.dir();
+    return path;
+});
+let buildTargetInstallation;
+// Installs the build target defined in `BUILD_TARGET`. The Promise is saved to
+// `buildTargetInstallation` so that we run the command just once for multiple
+// Rust functions.
+const installBuildTarget = () => {
+    if (buildTargetInstallation === undefined) {
+        buildTargetInstallation = runCommand('rustup', ['target', 'add', BUILD_TARGET]);
+    }
+    return buildTargetInstallation;
+};
+module.exports = { build };

package/dist/runtimes/rust/constants.d.ts

@@ -0,0 +1,2 @@
+export const BUILD_TARGET: "x86_64-unknown-linux-musl";
+export const MANIFEST_NAME: "Cargo.toml";

package/dist/runtimes/rust/constants.js

@@ -0,0 +1,3 @@
+const BUILD_TARGET = 'x86_64-unknown-linux-musl';
+const MANIFEST_NAME = 'Cargo.toml';
+module.exports = { BUILD_TARGET, MANIFEST_NAME };

package/dist/runtimes/rust/index.d.ts

@@ -0,0 +1,20 @@
+export function findFunctionsInPaths({ featureFlags, fsCache, paths }: {
+    featureFlags: any;
+    fsCache: any;
+    paths: any;
+}): Promise<any[]>;
+import { RUNTIME_RUST } from "../../utils/consts";
+export function zipFunction({ config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat }: {
+    config: any;
+    destFolder: any;
+    filename: any;
+    mainFile: any;
+    runtime: any;
+    srcDir: any;
+    srcPath: any;
+    stat: any;
+}): Promise<{
+    config: any;
+    path: string;
+}>;
+export { RUNTIME_RUST as name };

package/dist/runtimes/rust/index.js

@@ -0,0 +1,101 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { join, extname, dirname, basename } = require('path');
+const { RUNTIME_RUST } = require('../../utils/consts');
+const { cachedLstat, cachedReaddir } = require('../../utils/fs');
+const { zipBinary } = require('../../zip_binary');
+const { detectBinaryRuntime } = require('../detect_runtime');
+const { build } = require('./builder');
+const { MANIFEST_NAME } = require('./constants');
+const detectRustFunction = ({ fsCache, path }) => __awaiter(this, void 0, void 0, function* () {
+    const stat = yield cachedLstat(fsCache, path);
+    if (!stat.isDirectory()) {
+        return;
+    }
+    const files = yield cachedReaddir(fsCache, path);
+    const hasCargoManifest = files.includes(MANIFEST_NAME);
+    if (!hasCargoManifest) {
+        return;
+    }
+    const mainFilePath = join(path, 'src', 'main.rs');
+    try {
+        const mainFile = yield cachedLstat(fsCache, mainFilePath);
+        if (mainFile.isFile()) {
+            return mainFilePath;
+        }
+    }
+    catch (_) {
+        // no-op
+    }
+});
+const findFunctionsInPaths = function ({ featureFlags, fsCache, paths }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const functions = yield Promise.all(paths.map((path) => __awaiter(this, void 0, void 0, function* () {
+            const runtime = yield detectBinaryRuntime({ fsCache, path });
+            if (runtime === RUNTIME_RUST) {
+                return processBinary({ fsCache, path });
+            }
+            if (featureFlags.buildRustSource !== true) {
+                return;
+            }
+            const rustSourceFile = yield detectRustFunction({ fsCache, path });
+            if (rustSourceFile) {
+                return processSource({ fsCache, mainFile: rustSourceFile, path });
+            }
+        })));
+        return functions.filter(Boolean);
+    });
+};
+const processBinary = ({ fsCache, path }) => __awaiter(this, void 0, void 0, function* () {
+    const stat = yield cachedLstat(fsCache, path);
+    const name = basename(path, extname(path));
+    return {
+        mainFile: path,
+        name,
+        srcDir: dirname(path),
+        srcPath: path,
+        stat,
+    };
+});
+const processSource = ({ mainFile, path }) => {
+    const functionName = basename(path);
+    return {
+        mainFile,
+        name: functionName,
+        srcDir: path,
+        srcPath: path,
+    };
+};
+// The name of the binary inside the zip file must always be `bootstrap`
+// because they include the Lambda runtime, and that's the name that AWS
+// expects for those kind of functions.
+const zipFunction = function ({ config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const destPath = join(destFolder, `${filename}.zip`);
+        const isSource = extname(mainFile) === '.rs';
+        const zipOptions = {
+            destPath,
+            filename: 'bootstrap',
+            runtime,
+        };
+        // If we're building from source, we first need to build the source and zip
+        // the resulting binary. Otherwise, we're dealing with a binary so we zip it
+        // directly.
+        if (isSource) {
+            const { path: binaryPath, stat: binaryStat } = yield build({ config, name: filename, srcDir });
+            yield zipBinary(Object.assign(Object.assign({}, zipOptions), { srcPath: binaryPath, stat: binaryStat }));
+        }
+        else {
+            yield zipBinary(Object.assign(Object.assign({}, zipOptions), { srcPath, stat }));
+        }
+        return { config, path: destPath };
+    });
+};
+module.exports = { findFunctionsInPaths, name: RUNTIME_RUST, zipFunction };

package/dist/utils/consts.d.ts

@@ -0,0 +1,8 @@
+export const ARCHIVE_FORMAT_NONE: string;
+export const ARCHIVE_FORMAT_ZIP: string;
+export const JS_BUNDLER_ESBUILD: string;
+export const JS_BUNDLER_ESBUILD_ZISI: string;
+export const JS_BUNDLER_ZISI: string;
+export const RUNTIME_GO: string;
+export const RUNTIME_JS: string;
+export const RUNTIME_RUST: string;

package/dist/utils/consts.js

@@ -0,0 +1,10 @@
+module.exports = {
+    ARCHIVE_FORMAT_NONE: 'none',
+    ARCHIVE_FORMAT_ZIP: 'zip',
+    JS_BUNDLER_ESBUILD: 'esbuild',
+    JS_BUNDLER_ESBUILD_ZISI: 'esbuild_zisi',
+    JS_BUNDLER_ZISI: 'zisi',
+    RUNTIME_GO: 'go',
+    RUNTIME_JS: 'js',
+    RUNTIME_RUST: 'rs',
+};

package/dist/utils/fs.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+export function cachedLstat(...args: any[]): any;
+export function cachedReaddir(...args: any[]): any;
+export function cachedReadFile(...args: any[]): any;
+declare const pLstat: typeof lstat.__promisify__;
+export function getPathWithExtension(path: any, extension: any): string;
+export function listFunctionsDirectories(srcFolders: any): Promise<any[]>;
+export function listFunctionsDirectory(srcFolder: any): Promise<string[]>;
+export function resolveFunctionsDirectories(input: any): string[];
+export function safeUnlink(path: any): Promise<void>;
+declare const pWriteFile: typeof writeFile.__promisify__;
+import { lstat } from "fs";
+import { writeFile } from "fs";
+export { pLstat as lstat, pWriteFile as writeFile };

package/dist/utils/fs.js

@@ -0,0 +1,86 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { lstat, readdir, readFile, unlink, writeFile } = require('fs');
+const { format, join, parse, resolve } = require('path');
+const { promisify } = require('util');
+const pLstat = promisify(lstat);
+const pReaddir = promisify(readdir);
+const pReadFile = promisify(readFile);
+const pUnlink = promisify(unlink);
+const pWriteFile = promisify(writeFile);
+// This caches multiple FS calls to the same path. It creates a cache key with
+// the name of the function and the path (e.g. "readdir:/some/directory").
+const cachedIOFunction = (func, cache, path, ...args) => {
+    const key = `${func.name}:${path}`;
+    if (cache[key] === undefined) {
+        // eslint-disable-next-line no-param-reassign
+        cache[key] = func(path, ...args);
+    }
+    return cache[key];
+};
+const cachedLstat = (...args) => cachedIOFunction(pLstat, ...args);
+const cachedReaddir = (...args) => cachedIOFunction(pReaddir, ...args);
+const cachedReadFile = (...args) => cachedIOFunction(pReadFile, ...args);
+const getPathWithExtension = (path, extension) => format(Object.assign(Object.assign({}, parse(path)), { base: undefined, ext: extension }));
+const safeUnlink = (path) => __awaiter(this, void 0, void 0, function* () {
+    try {
+        yield pUnlink(path);
+    }
+    catch (_) { }
+});
+// Takes a list of absolute paths and returns an array containing all the
+// filenames within those directories, if at least one of the directories
+// exists. If not, an error is thrown.
+const listFunctionsDirectories = function (srcFolders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filenamesByDirectory = yield Promise.all(srcFolders.map((srcFolder) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const filenames = yield listFunctionsDirectory(srcFolder);
+                return filenames;
+            }
+            catch (error) {
+                return null;
+            }
+        })));
+        const validDirectories = filenamesByDirectory.filter(Boolean);
+        if (validDirectories.length === 0) {
+            throw new Error(`Functions folder does not exist: ${srcFolders.join(', ')}`);
+        }
+        return validDirectories.flat();
+    });
+};
+const listFunctionsDirectory = function (srcFolder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const filenames = yield pReaddir(srcFolder);
+            return filenames.map((name) => join(srcFolder, name));
+        }
+        catch (error) {
+            throw new Error(`Functions folder does not exist: ${srcFolder}`);
+        }
+    });
+};
+const resolveFunctionsDirectories = (input) => {
+    const directories = Array.isArray(input) ? input : [input];
+    const absoluteDirectories = directories.map((srcFolder) => resolve(srcFolder));
+    return absoluteDirectories;
+};
+module.exports = {
+    cachedLstat,
+    cachedReaddir,
+    cachedReadFile,
+    lstat: pLstat,
+    getPathWithExtension,
+    listFunctionsDirectories,
+    listFunctionsDirectory,
+    resolveFunctionsDirectories,
+    safeUnlink,
+    writeFile: pWriteFile,
+};

package/dist/utils/polyfills.d.ts

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

package/{src → dist}/utils/polyfills.js

@@ -1,3 +1,3 @@
 // Patches `Array.flat()` and `Array.flatMap()`
 // TODO: remove after dropping Node <12 support
-require('array-flat-polyfill')
+require('array-flat-polyfill');

package/dist/utils/remove_falsy.d.ts

@@ -0,0 +1 @@
+export function removeFalsy(obj: any): Partial<any>;

package/dist/utils/remove_falsy.js

@@ -0,0 +1,9 @@
+const filterObj = require('filter-obj');
+// Remove falsy values from object
+const removeFalsy = function (obj) {
+    return filterObj(obj, isDefined);
+};
+const isDefined = function (key, value) {
+    return value !== undefined && value !== '';
+};
+module.exports = { removeFalsy };

package/dist/utils/shell.d.ts

@@ -0,0 +1,2 @@
+import execa = require("execa");
+export { execa as runCommand };

package/dist/utils/shell.js

@@ -0,0 +1,2 @@
+const execa = require('execa');
+module.exports = { runCommand: execa };

package/dist/zip.d.ts

@@ -0,0 +1,15 @@
+export function zipFunction(relativeSrcPath: any, destFolder: any, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, pluginsModulesPath: defaultModulesPath, }?: {
+    archiveFormat?: string;
+    basePath: any;
+    config?: {};
+    featureFlags: any;
+    pluginsModulesPath: any;
+}): Promise<Partial<any>>;
+export function zipFunctions(relativeSrcFolders: any, destFolder: any, { archiveFormat, basePath, config, featureFlags: inputFeatureFlags, manifest, parallelLimit, }?: {
+    archiveFormat?: string;
+    basePath: any;
+    config?: {};
+    featureFlags: any;
+    manifest: any;
+    parallelLimit?: number;
+}): Promise<Partial<any>[]>;

package/dist/zip.js

@@ -0,0 +1,116 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { resolve } = require('path');
+const makeDir = require('make-dir');
+const pMap = require('p-map');
+const { getFlags } = require('./feature_flags');
+const { createManifest } = require('./manifest');
+const { getPluginsModulesPath } = require('./node_dependencies');
+const { getFunctionsFromPaths } = require('./runtimes');
+const { ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP } = require('./utils/consts');
+const { listFunctionsDirectories, resolveFunctionsDirectories } = require('./utils/fs');
+const { removeFalsy } = require('./utils/remove_falsy');
+const DEFAULT_PARALLEL_LIMIT = 5;
+const validateArchiveFormat = (archiveFormat) => {
+    if (![ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP].includes(archiveFormat)) {
+        throw new Error(`Invalid archive format: ${archiveFormat}`);
+    }
+};
+// Takes the result of zipping a function and formats it for output.
+const formatZipResult = (result) => {
+    const { bundler, bundlerErrors, bundlerWarnings, config = {}, inputs, mainFile, name, nativeNodeModules, nodeModulesWithDynamicImports, path, runtime, } = result;
+    return removeFalsy({
+        bundler,
+        bundlerErrors,
+        bundlerWarnings,
+        config,
+        inputs,
+        mainFile,
+        name,
+        nativeNodeModules,
+        nodeModulesWithDynamicImports,
+        path,
+        runtime: runtime.name,
+    });
+};
+// Zip `srcFolder/*` (Node.js or Go files) to `destFolder/*.zip` so it can be
+// used by AWS Lambda
+const zipFunctions = function (relativeSrcFolders, destFolder, { archiveFormat = ARCHIVE_FORMAT_ZIP, basePath, config = {}, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        validateArchiveFormat(archiveFormat);
+        const featureFlags = getFlags(inputFeatureFlags);
+        const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
+        const [paths] = yield Promise.all([listFunctionsDirectories(srcFolders), makeDir(destFolder)]);
+        const [functions, pluginsModulesPath] = yield Promise.all([
+            getFunctionsFromPaths(paths, { config, dedupe: true, featureFlags }),
+            // All function directories should be part of the same project root, so we
+            // can get away with computing the plugins modules path from any of the
+            // source directories.
+            getPluginsModulesPath(srcFolders[0]),
+        ]);
+        const results = yield pMap(functions.values(), (func) => __awaiter(this, void 0, void 0, function* () {
+            const zipResult = yield func.runtime.zipFunction({
+                archiveFormat,
+                basePath,
+                config: func.config,
+                destFolder,
+                extension: func.extension,
+                filename: func.filename,
+                mainFile: func.mainFile,
+                name: func.name,
+                pluginsModulesPath,
+                runtime: func.runtime,
+                srcDir: func.srcDir,
+                srcPath: func.srcPath,
+                stat: func.stat,
+                featureFlags,
+            });
+            return Object.assign(Object.assign({}, zipResult), { mainFile: func.mainFile, name: func.name, runtime: func.runtime });
+        }), {
+            concurrency: parallelLimit,
+        });
+        const formattedResults = results.filter(Boolean).map(formatZipResult);
+        if (manifest !== undefined) {
+            yield createManifest({ functions: formattedResults, path: resolve(manifest) });
+        }
+        return formattedResults;
+    });
+};
+const zipFunction = function (relativeSrcPath, destFolder, { archiveFormat = ARCHIVE_FORMAT_ZIP, basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, pluginsModulesPath: defaultModulesPath, } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        validateArchiveFormat(archiveFormat);
+        const featureFlags = getFlags(inputFeatureFlags);
+        const srcPath = resolve(relativeSrcPath);
+        const functions = yield getFunctionsFromPaths([srcPath], { config: inputConfig, dedupe: true, featureFlags });
+        if (functions.size === 0) {
+            return;
+        }
+        const { config, extension, filename, mainFile, name, runtime, srcDir, stat } = functions.values().next().value;
+        const pluginsModulesPath = defaultModulesPath === undefined ? yield getPluginsModulesPath(srcPath) : defaultModulesPath;
+        yield makeDir(destFolder);
+        const zipResult = yield runtime.zipFunction({
+            archiveFormat,
+            basePath,
+            config,
+            srcPath,
+            destFolder,
+            mainFile,
+            filename,
+            extension,
+            srcDir,
+            stat,
+            runtime,
+            pluginsModulesPath,
+            featureFlags,
+        });
+        return formatZipResult(Object.assign(Object.assign({}, zipResult), { mainFile, name, runtime }));
+    });
+};
+module.exports = { zipFunction, zipFunctions };

package/dist/zip_binary.d.ts

@@ -0,0 +1,7 @@
+export function zipBinary({ srcPath, destPath, filename, stat, runtime }: {
+    srcPath: any;
+    destPath: any;
+    filename: any;
+    stat: any;
+    runtime: any;
+}): Promise<void>;

package/dist/zip_binary.js

@@ -0,0 +1,20 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { startZip, addZipFile, addZipContent, endZip } = require('./archive');
+// Zip a binary function file
+const zipBinary = function ({ srcPath, destPath, filename, stat, runtime }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { archive, output } = startZip(destPath);
+        addZipFile(archive, srcPath, filename, stat);
+        addZipContent(archive, JSON.stringify({ runtime: runtime.name }), 'netlify-toolchain');
+        yield endZip(archive, output);
+    });
+};
+module.exports = { zipBinary };

package/dist/zip_node.d.ts

@@ -0,0 +1,4 @@
+export function zipNodeJs({ archiveFormat, ...options }: {
+    [x: string]: any;
+    archiveFormat: any;
+}): Promise<string>;