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

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

@@ -0,0 +1,16 @@
+import { findFunctionsInPaths } from "./finder";
+declare function getSrcFilesWithBundler(parameters: any): Promise<any[]>;
+import { RUNTIME_JS } from "../../utils/consts";
+declare function zipWithFunctionWithFallback({ config, ...parameters }: {
+    [x: string]: any;
+    config?: {};
+}): Promise<{
+    bundler: string;
+    config: any;
+    inputs: any[];
+    path: string;
+} | {
+    config: {};
+    path: string;
+}>;
+export { findFunctionsInPaths, getSrcFilesWithBundler as getSrcFiles, RUNTIME_JS as name, zipWithFunctionWithFallback as zipFunction };

package/dist/runtimes/node/index.js

@@ -0,0 +1,118 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+const { join } = require('path');
+const cpFile = require('cp-file');
+const { JS_BUNDLER_ESBUILD, JS_BUNDLER_ESBUILD_ZISI, JS_BUNDLER_ZISI, RUNTIME_JS } = require('../../utils/consts');
+const { detectEsModule } = require('./detect_es_module');
+const { findFunctionsInPaths } = require('./finder');
+const { getSrcFiles } = require('./src_files');
+const { zipEsbuild } = require('./zip_esbuild');
+const { zipZisi } = require('./zip_zisi');
+// We use ZISI as the default bundler, except for certain extensions, for which
+// esbuild is the only option.
+const getDefaultBundler = ({ extension, mainFile, featureFlags = {} }) => __awaiter(this, void 0, void 0, function* () {
+    if (['.mjs', '.ts'].includes(extension)) {
+        return JS_BUNDLER_ESBUILD;
+    }
+    if (featureFlags.defaultEsModulesToEsbuild) {
+        const isEsModule = yield detectEsModule({ mainFile });
+        if (isEsModule) {
+            return JS_BUNDLER_ESBUILD;
+        }
+    }
+    return JS_BUNDLER_ZISI;
+});
+// A proxy for the `getSrcFiles` function which adds a default `bundler` using
+// the `getDefaultBundler` function.
+const getSrcFilesWithBundler = (parameters) => __awaiter(this, void 0, void 0, function* () {
+    const bundler = parameters.config.nodeBundler || (yield getDefaultBundler({ extension: parameters.extension }));
+    return getSrcFiles(Object.assign(Object.assign({}, parameters), { bundler }));
+});
+const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const bundler = config.nodeBundler || (yield getDefaultBundler({ extension, mainFile, featureFlags }));
+        // If the file is a zip, we assume the function is bundled and ready to go.
+        // We simply copy it to the destination path with no further processing.
+        if (extension === '.zip') {
+            const destPath = join(destFolder, filename);
+            yield cpFile(srcPath, destPath);
+            return { config, path: destPath };
+        }
+        if (bundler === JS_BUNDLER_ZISI) {
+            return zipZisi({
+                archiveFormat,
+                basePath,
+                config,
+                destFolder,
+                extension,
+                featureFlags,
+                filename,
+                mainFile,
+                name,
+                pluginsModulesPath,
+                srcDir,
+                srcPath,
+                stat,
+            });
+        }
+        return zipEsbuild({
+            archiveFormat,
+            basePath,
+            config,
+            destFolder,
+            extension,
+            filename,
+            mainFile,
+            name,
+            pluginsModulesPath,
+            srcDir,
+            srcPath,
+            stat,
+        });
+    });
+};
+const zipWithFunctionWithFallback = (_a) => __awaiter(this, void 0, void 0, function* () {
+    var { config = {} } = _a, parameters = __rest(_a, ["config"]);
+    // If a specific JS bundler version is specified, we'll use it.
+    if (config.nodeBundler !== JS_BUNDLER_ESBUILD_ZISI) {
+        return zipFunction(Object.assign(Object.assign({}, parameters), { config }));
+    }
+    // Otherwise, we'll try to bundle with esbuild and, if that fails, fallback
+    // to zisi.
+    try {
+        return yield zipFunction(Object.assign(Object.assign({}, parameters), { config: Object.assign(Object.assign({}, config), { nodeBundler: JS_BUNDLER_ESBUILD }) }));
+    }
+    catch (esbuildError) {
+        try {
+            const data = yield zipFunction(Object.assign(Object.assign({}, parameters), { config: Object.assign(Object.assign({}, config), { nodeBundler: JS_BUNDLER_ZISI }) }));
+            return Object.assign(Object.assign({}, data), { bundlerErrors: esbuildError.errors });
+        }
+        catch (zisiError) {
+            throw esbuildError;
+        }
+    }
+});
+module.exports = {
+    findFunctionsInPaths,
+    getSrcFiles: getSrcFilesWithBundler,
+    name: RUNTIME_JS,
+    zipFunction: zipWithFunctionWithFallback,
+};

package/dist/runtimes/node/list_imports.d.ts

@@ -0,0 +1,4 @@
+export function listImports({ functionName, path }: {
+    functionName: any;
+    path: any;
+}): Promise<any[]>;

package/dist/runtimes/node/list_imports.js

@@ -0,0 +1,68 @@
+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 esbuild = require('@netlify/esbuild');
+const isBuiltinModule = require('is-builtin-module');
+const { tmpName } = require('tmp-promise');
+const { JS_BUNDLER_ZISI, RUNTIME_JS } = require('../../utils/consts');
+const { safeUnlink } = require('../../utils/fs');
+// Maximum number of log messages that an esbuild instance will produce. This
+// limit is important to avoid out-of-memory errors due to too much data being
+// sent in the Go<>Node IPC channel.
+const ESBUILD_LOG_LIMIT = 10;
+const getListImportsPlugin = ({ imports, path }) => ({
+    name: 'list-imports',
+    setup(build) {
+        build.onResolve({ filter: /.*/ }, (args) => {
+            const isEntryPoint = args.path === path;
+            const isImport = !isEntryPoint && !isBuiltinModule(args.path);
+            if (isImport) {
+                imports.add(args.path);
+            }
+            return {
+                namespace: 'list-imports',
+                external: isImport,
+            };
+        });
+    },
+});
+const listImports = ({ functionName, path }) => __awaiter(this, void 0, void 0, function* () {
+    // We're not interested in the output that esbuild generates, we're just
+    // using it for its parsing capabilities in order to find import/require
+    // statements. However, if we don't give esbuild a path in `outfile`, it
+    // will pipe the output to stdout, which we also don't want. So we create
+    // a temporary file to serve as the esbuild output and then get rid of it
+    // when we're done.
+    const targetPath = yield tmpName();
+    const imports = new Set();
+    try {
+        yield esbuild.build({
+            bundle: true,
+            entryPoints: [path],
+            logLevel: 'error',
+            logLimit: ESBUILD_LOG_LIMIT,
+            outfile: targetPath,
+            platform: 'node',
+            plugins: [getListImportsPlugin({ imports, path })],
+            target: 'esnext',
+        });
+    }
+    catch (error) {
+        error.customErrorInfo = {
+            type: 'functionsBundling',
+            location: { bundler: JS_BUNDLER_ZISI, functionName, runtime: RUNTIME_JS },
+        };
+        throw error;
+    }
+    finally {
+        yield safeUnlink(targetPath);
+    }
+    return [...imports];
+});
+module.exports = { listImports };

package/dist/runtimes/node/native_modules/detector.d.ts

@@ -0,0 +1,7 @@
+export function isNativeModule({ binary, dependencies, devDependencies, files, gypfile }: {
+    binary: any;
+    dependencies?: {};
+    devDependencies?: {};
+    files?: any[];
+    gypfile: any;
+}): boolean;

package/dist/runtimes/node/native_modules/detector.js

@@ -0,0 +1,14 @@
+const { extname } = require('path');
+const markerModules = ['bindings', 'nan', 'node-gyp', 'node-gyp-build', 'node-pre-gyp', 'prebuild'];
+const isNativeModule = ({ binary, dependencies = {}, devDependencies = {}, files = [], gypfile }) => {
+    if (binary || gypfile) {
+        return true;
+    }
+    const hasMarkerModule = markerModules.some((marker) => dependencies[marker] || devDependencies[marker]);
+    if (hasMarkerModule) {
+        return true;
+    }
+    const hasBinaryFile = files.some((path) => !path.startsWith('!') && extname(path) === '.node');
+    return hasBinaryFile;
+};
+module.exports = { isNativeModule };

package/dist/runtimes/node/native_modules/plugin.d.ts

@@ -0,0 +1,4 @@
+export function getNativeModulesPlugin(externalizedModules: any): {
+    name: string;
+    setup(build: any): void;
+};

package/dist/runtimes/node/native_modules/plugin.js

@@ -0,0 +1,65 @@
+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 path = require('path');
+const readPackageJson = require('read-package-json-fast');
+const { isNativeModule } = require('./detector');
+// Filters out relative or absolute file paths.
+const packageFilter = /^([^./]*)$/;
+// Filters valid package names and extracts the base directory.
+const packageName = /^([^@][^/]*|@[^/]*\/[^/]+)(?:\/|$)/;
+const findNativeModule = (packageJsonPath, cache) => {
+    if (cache[packageJsonPath] === undefined) {
+        // eslint-disable-next-line no-param-reassign, promise/prefer-await-to-then
+        cache[packageJsonPath] = readPackageJson(packageJsonPath).then((data) => [Boolean(isNativeModule(data), data), data], () => []);
+    }
+    return cache[packageJsonPath];
+};
+const getNativeModulesPlugin = (externalizedModules) => ({
+    name: 'external-native-modules',
+    setup(build) {
+        const cache = {};
+        // eslint-disable-next-line complexity, max-statements
+        build.onResolve({ filter: packageFilter }, (args) => __awaiter(this, void 0, void 0, function* () {
+            const package = packageName.exec(args.path);
+            if (!package)
+                return;
+            let directory = args.resolveDir;
+            while (true) {
+                if (path.basename(directory) !== 'node_modules') {
+                    const modulePath = path.join(directory, 'node_modules', package[1]);
+                    const packageJsonPath = path.join(modulePath, 'package.json');
+                    // eslint-disable-next-line no-await-in-loop
+                    const [isNative, packageJsonData] = yield findNativeModule(packageJsonPath, cache);
+                    // eslint-disable-next-line max-depth
+                    if (isNative === true) {
+                        // eslint-disable-next-line max-depth
+                        if (externalizedModules[args.path] === undefined) {
+                            // eslint-disable-next-line no-param-reassign
+                            externalizedModules[args.path] = {};
+                        }
+                        // eslint-disable-next-line no-param-reassign
+                        externalizedModules[args.path][modulePath] = packageJsonData.version;
+                        return { path: args.path, external: true };
+                    }
+                    // eslint-disable-next-line max-depth
+                    if (isNative === false) {
+                        return;
+                    }
+                }
+                const parentDirectory = path.dirname(directory);
+                if (parentDirectory === directory) {
+                    break;
+                }
+                directory = parentDirectory;
+            }
+        }));
+    },
+});
+module.exports = { getNativeModulesPlugin };

package/dist/runtimes/node/src_files.d.ts

@@ -0,0 +1,20 @@
+export function getSrcFiles({ config, ...parameters }: {
+    [x: string]: any;
+    config: any;
+}): Promise<any[]>;
+export function getSrcFilesAndExternalModules({ bundler, externalNodeModules, featureFlags, includedFiles, includedFilesBasePath, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }: {
+    bundler: any;
+    externalNodeModules?: any[];
+    featureFlags: any;
+    includedFiles?: any[];
+    includedFilesBasePath: any;
+    mainFile: any;
+    name: any;
+    pluginsModulesPath: any;
+    srcDir: any;
+    srcPath: any;
+    stat: any;
+}): Promise<{
+    moduleNames: any[];
+    paths: any[];
+}>;

package/dist/runtimes/node/src_files.js

@@ -0,0 +1,84 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+const { normalize } = require('path');
+const { promisify } = require('util');
+const glob = require('glob');
+const pGlob = promisify(glob);
+const { getDependencyNamesAndPathsForDependencies, listFilesUsingLegacyBundler } = require('../../node_dependencies');
+const { JS_BUNDLER_ZISI } = require('../../utils/consts');
+const getPathsOfIncludedFiles = (includedFiles, basePath) => __awaiter(this, void 0, void 0, function* () {
+    // Some of the globs in `includedFiles` might be exclusion patterns, which
+    // means paths that should NOT be included in the bundle. We need to treat
+    // these differently, so we iterate on the array and put those paths in a
+    // `exclude` array and the rest of the paths in an `include` array.
+    const { include, exclude } = includedFiles.reduce((acc, path) => {
+        if (path.startsWith('!')) {
+            return Object.assign(Object.assign({}, acc), { exclude: [...acc.exclude, path.slice(1)] });
+        }
+        return Object.assign(Object.assign({}, acc), { include: [...acc.include, path] });
+    }, { include: [], exclude: [] });
+    const pathGroups = yield Promise.all(include.map((expression) => pGlob(expression, { absolute: true, cwd: basePath, ignore: exclude, nodir: true })));
+    // `pathGroups` is an array containing the paths for each expression in the
+    // `include` array. We flatten it into a single dimension.
+    const paths = pathGroups.flat();
+    const normalizedPaths = paths.map(normalize);
+    return [...new Set(normalizedPaths)];
+});
+const getSrcFiles = function (_a) {
+    var { config } = _a, parameters = __rest(_a, ["config"]);
+    return __awaiter(this, void 0, void 0, function* () {
+        const { paths } = yield getSrcFilesAndExternalModules(Object.assign(Object.assign({}, parameters), { externalNodeModules: config.externalNodeModules }));
+        return paths;
+    });
+};
+const getSrcFilesAndExternalModules = function ({ bundler, externalNodeModules = [], featureFlags, includedFiles = [], includedFilesBasePath, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const includedFilePaths = yield getPathsOfIncludedFiles(includedFiles, includedFilesBasePath);
+        if (bundler === JS_BUNDLER_ZISI) {
+            const paths = yield listFilesUsingLegacyBundler({
+                featureFlags,
+                srcPath,
+                mainFile,
+                name,
+                srcDir,
+                stat,
+                pluginsModulesPath,
+            });
+            return {
+                moduleNames: [],
+                paths: [...paths, ...includedFilePaths],
+            };
+        }
+        if (externalNodeModules.length !== 0) {
+            const { moduleNames, paths } = yield getDependencyNamesAndPathsForDependencies({
+                dependencies: externalNodeModules,
+                basedir: srcDir,
+                pluginsModulesPath,
+            });
+            return { moduleNames, paths: [...paths, ...includedFilePaths, mainFile] };
+        }
+        return {
+            moduleNames: externalNodeModules,
+            paths: [mainFile, ...includedFilePaths],
+        };
+    });
+};
+module.exports = { getSrcFiles, getSrcFilesAndExternalModules };

package/dist/runtimes/node/zip_esbuild.d.ts

@@ -0,0 +1,22 @@
+export function zipEsbuild({ archiveFormat, basePath, config, destFolder, extension, filename, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }: {
+    archiveFormat: any;
+    basePath: any;
+    config?: {};
+    destFolder: any;
+    extension: any;
+    filename: any;
+    mainFile: any;
+    name: any;
+    pluginsModulesPath: any;
+    srcDir: any;
+    srcPath: any;
+    stat: any;
+}): Promise<{
+    bundler: string;
+    bundlerWarnings: import("@netlify/esbuild").Message[];
+    config: {};
+    inputs: string[];
+    nativeNodeModules: {};
+    nodeModulesWithDynamicImports: any[];
+    path: string;
+}>;

package/dist/runtimes/node/zip_esbuild.js

@@ -0,0 +1,95 @@
+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 { dirname, normalize } = require('path');
+const { getExternalAndIgnoredModulesFromSpecialCases } = require('../../node_dependencies');
+const { JS_BUNDLER_ESBUILD } = require('../../utils/consts');
+const { getPathWithExtension } = require('../../utils/fs');
+const { zipNodeJs } = require('../../zip_node');
+const { getBasePath } = require('./base_path');
+const { bundleJsFile } = require('./bundler');
+const { getSrcFilesAndExternalModules } = require('./src_files');
+const getFunctionBasePath = ({ basePathFromConfig, mainFile, supportingSrcFiles }) => {
+    // If there is a base path defined in the config, we use that.
+    if (basePathFromConfig !== undefined) {
+        return basePathFromConfig;
+    }
+    // If not, the base path is the common path prefix between all the supporting
+    // files and the main file.
+    const dirnames = [...supportingSrcFiles, mainFile].map((filePath) => normalize(dirname(filePath)));
+    return getBasePath(dirnames);
+};
+// Convenience method for retrieving external and ignored modules from
+// different places and merging them together.
+const getExternalAndIgnoredModules = ({ config, srcDir }) => __awaiter(this, void 0, void 0, function* () {
+    const { externalNodeModules: externalModulesFromConfig = [], ignoredNodeModules: ignoredModulesFromConfig = [] } = config;
+    const { externalModules: externalModulesFromSpecialCases, ignoredModules: ignoredModulesFromSpecialCases } = yield getExternalAndIgnoredModulesFromSpecialCases({ srcDir });
+    const externalModules = [...new Set([...externalModulesFromConfig, ...externalModulesFromSpecialCases])];
+    const ignoredModules = [...ignoredModulesFromConfig, ...ignoredModulesFromSpecialCases];
+    return { externalModules, ignoredModules };
+});
+const zipEsbuild = ({ archiveFormat, basePath, config = {}, destFolder, extension, filename, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) => __awaiter(this, void 0, void 0, function* () {
+    const { externalModules, ignoredModules } = yield getExternalAndIgnoredModules({ config, srcDir });
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = yield bundleJsFile({
+        additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
+        basePath,
+        config,
+        destFilename: filename,
+        externalModules,
+        ignoredModules,
+        name,
+        srcDir,
+        srcFile: mainFile,
+    });
+    const bundlerWarnings = warnings.length === 0 ? undefined : warnings;
+    const { paths: srcFiles } = yield getSrcFilesAndExternalModules({
+        externalNodeModules: [...externalModules, ...Object.keys(nativeNodeModules)],
+        bundler: JS_BUNDLER_ESBUILD,
+        includedFiles: [...(config.includedFiles || []), ...additionalPaths],
+        includedFilesBasePath: config.includedFilesBasePath || basePath,
+        mainFile,
+        name,
+        srcPath,
+        srcDir,
+        pluginsModulesPath,
+        stat,
+    });
+    // We want to remove `mainFile` from `srcFiles` because it represents the
+    // path of the original, pre-bundling function file. We'll add the actual
+    // bundled file further below.
+    const supportingSrcFiles = srcFiles.filter((path) => path !== mainFile);
+    const normalizedMainFile = getPathWithExtension(mainFile, '.js');
+    const functionBasePath = getFunctionBasePath({ basePathFromConfig: basePath, mainFile, supportingSrcFiles });
+    try {
+        const path = yield zipNodeJs({
+            aliases: bundlePaths,
+            archiveFormat,
+            basePath: functionBasePath,
+            destFolder,
+            extension,
+            filename,
+            mainFile: normalizedMainFile,
+            pluginsModulesPath,
+            srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],
+        });
+        return {
+            bundler: JS_BUNDLER_ESBUILD,
+            bundlerWarnings,
+            config,
+            inputs,
+            nativeNodeModules,
+            nodeModulesWithDynamicImports,
+            path,
+        };
+    }
+    finally {
+        yield cleanTempFiles();
+    }
+});
+module.exports = { zipEsbuild };

package/dist/runtimes/node/zip_zisi.d.ts

@@ -0,0 +1,20 @@
+export function zipZisi({ archiveFormat, basePath, config, destFolder, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }: {
+    archiveFormat: any;
+    basePath: any;
+    config: any;
+    destFolder: any;
+    extension: any;
+    featureFlags: any;
+    filename: any;
+    mainFile: any;
+    name: any;
+    pluginsModulesPath: any;
+    srcDir: any;
+    srcPath: any;
+    stat: any;
+}): Promise<{
+    bundler: string;
+    config: any;
+    inputs: any[];
+    path: string;
+}>;

package/dist/runtimes/node/zip_zisi.js

@@ -0,0 +1,42 @@
+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 { dirname, normalize } = require('path');
+const { JS_BUNDLER_ZISI } = require('../../utils/consts');
+const { zipNodeJs } = require('../../zip_node');
+const { getBasePath } = require('./base_path');
+const { getSrcFilesAndExternalModules } = require('./src_files');
+const zipZisi = ({ archiveFormat, basePath, config, destFolder, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) => __awaiter(this, void 0, void 0, function* () {
+    const { paths: srcFiles } = yield getSrcFilesAndExternalModules({
+        bundler: JS_BUNDLER_ZISI,
+        extension,
+        featureFlags,
+        includedFiles: config.includedFiles,
+        includedFilesBasePath: config.includedFilesBasePath || basePath,
+        mainFile,
+        name,
+        pluginsModulesPath,
+        srcDir,
+        srcPath,
+        stat,
+    });
+    const dirnames = srcFiles.map((filePath) => normalize(dirname(filePath)));
+    const path = yield zipNodeJs({
+        archiveFormat,
+        basePath: getBasePath(dirnames),
+        destFolder,
+        extension,
+        filename,
+        mainFile,
+        pluginsModulesPath,
+        srcFiles,
+    });
+    return { bundler: JS_BUNDLER_ZISI, config, inputs: srcFiles, path };
+});
+module.exports = { zipZisi };

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export function build({ config, name, srcDir }: {
+    config: any;
+    name: any;
+    srcDir: any;
+}): Promise<{
+    path: string;
+    stat: import("fs").Stats;
+}>;