@netlify/zip-it-and-ship-it 5.5.2 → 5.7.2

package/dist/bin.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const process_1 = require("process");
 const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
 const main_1 = require("./main");
 // CLI entry point
 const runCli = async function () {
@@ -23,7 +24,7 @@ const runCli = async function () {
     }
 };
 const parseArgs = function () {
-    return yargs_1.default
+    return (0, yargs_1.default)((0, helpers_1.hideBin)(process_1.argv))
         .command('* <srcFolder> <destFolder>', 'Create ZIP archives from a directory')
         .options(OPTIONS)
         .usage(USAGE)

package/dist/config.d.ts

@@ -1,7 +1,6 @@
 import { FunctionSource } from './function';
-import type { NodeBundlerName } from './runtimes/node';
-declare type SupportedVersionNumbers = 8 | 10 | 12 | 14;
-declare type NodeVersion = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+import type { NodeVersionString } from './runtimes/node';
+import type { NodeBundlerName } from './runtimes/node/bundlers';
 interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
@@ -9,7 +8,7 @@ interface FunctionConfig {
     ignoredNodeModules?: string[];
     nodeBundler?: NodeBundlerName;
     nodeSourcemap?: boolean;
-    nodeVersion?: NodeVersion;
+    nodeVersion?: NodeVersionString;
     processDynamicNodeImports?: boolean;
     rustTargetDirectory?: string;
     schedule?: string;

package/dist/feature_flags.js

@@ -8,6 +8,7 @@ const FLAGS = {
     defaultEsModulesToEsbuild: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
     parseWithEsbuild: false,
     traceWithNft: false,
+    zisi_pure_esm: false,
 };
 exports.defaultFlags = FLAGS;
 // List of supported flags and their default value.

package/dist/runtimes/go/builder.js

@@ -7,7 +7,7 @@ const shell_1 = require("../../utils/shell");
 const build = async ({ destPath, mainFile, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
     try {
-        await (0, shell_1.runCommand)('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+        await shell_1.shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
             cwd: srcDir,
             env: {
                 CGO_ENABLED: '0',

package/dist/runtimes/node/bundlers/esbuild/index.js

@@ -78,6 +78,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         bundlerWarnings,
         inputs,
         mainFile: normalizedMainFile,
+        moduleFormat: 'cjs',
         nativeNodeModules,
         nodeModulesWithDynamicImports,
         srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],

package/dist/runtimes/node/bundlers/esbuild/special_cases.js

@@ -4,15 +4,6 @@ exports.getExternalAndIgnoredModulesFromSpecialCases = void 0;
 const package_json_1 = require("../../utils/package_json");
 const EXTERNAL_MODULES = ['@prisma/client'];
 const IGNORED_MODULES = ['aws-sdk'];
-const getPackageJsonIfAvailable = async (srcDir) => {
-    try {
-        const packageJson = await (0, package_json_1.getPackageJson)(srcDir);
-        return packageJson;
-    }
-    catch {
-        return {};
-    }
-};
 const getModulesForNextJs = ({ dependencies, devDependencies }) => {
     const allDependencies = { ...dependencies, ...devDependencies };
     const externalModules = allDependencies.next ? ['critters', 'nanoid'] : [];
@@ -23,7 +14,7 @@ const getModulesForNextJs = ({ dependencies, devDependencies }) => {
     };
 };
 const getExternalAndIgnoredModulesFromSpecialCases = async ({ srcDir }) => {
-    const { dependencies = {}, devDependencies = {} } = await getPackageJsonIfAvailable(srcDir);
+    const { dependencies = {}, devDependencies = {} } = await (0, package_json_1.getPackageJsonIfAvailable)(srcDir);
     const { externalModules: nextJsExternalModules, ignoredModules: nextJsIgnoredModules } = getModulesForNextJs({
         dependencies,
         devDependencies,

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

@@ -1,8 +1,9 @@
 import type { Message } from '@netlify/esbuild';
-import type { NodeBundlerName } from '..';
 import { FunctionConfig } from '../../../config';
 import { FeatureFlag, FeatureFlags } from '../../../feature_flags';
 import { FunctionSource } from '../../../function';
+import { ModuleFormat } from '../utils/module_format';
+export declare type NodeBundlerName = 'esbuild' | 'esbuild_zisi' | 'nft' | 'zisi';
 declare type BundlerWarning = Message;
 declare type CleanupFunction = () => Promise<void>;
 declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
@@ -20,6 +21,7 @@ declare type BundleFunction = (args: {
     cleanupFunction?: CleanupFunction;
     inputs: string[];
     mainFile: string;
+    moduleFormat: ModuleFormat;
     nativeNodeModules?: NativeNodeModules;
     nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
@@ -36,5 +38,10 @@ interface NodeBundler {
     getSrcFiles: GetSrcFilesFunction;
 }
 declare const getBundler: (name: NodeBundlerName) => NodeBundler;
-export { getBundler };
+declare const getDefaultBundler: ({ extension, mainFile, featureFlags, }: {
+    extension: string;
+    mainFile: string;
+    featureFlags: FeatureFlags;
+}) => Promise<NodeBundlerName>;
+export { getBundler, getDefaultBundler };
 export type { BundleFunction, GetSrcFilesFunction, NativeNodeModules };

package/dist/runtimes/node/bundlers/index.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBundler = void 0;
+exports.getDefaultBundler = exports.getBundler = void 0;
+const detect_es_module_1 = require("../utils/detect_es_module");
 const esbuild_1 = __importDefault(require("./esbuild"));
 const nft_1 = __importDefault(require("./nft"));
 const zisi_1 = __importDefault(require("./zisi"));
@@ -21,4 +22,23 @@ const getBundler = (name) => {
     }
 };
 exports.getBundler = getBundler;
+// We use ZISI as the default bundler, except for certain extensions, for which
+// esbuild is the only option.
+const getDefaultBundler = async ({ extension, mainFile, featureFlags, }) => {
+    const { defaultEsModulesToEsbuild, traceWithNft } = featureFlags;
+    if (['.mjs', '.ts'].includes(extension)) {
+        return 'esbuild';
+    }
+    if (traceWithNft) {
+        return 'nft';
+    }
+    if (defaultEsModulesToEsbuild) {
+        const isEsModule = await (0, detect_es_module_1.detectEsModule)({ mainFile });
+        if (isEsModule) {
+            return 'esbuild';
+        }
+    }
+    return 'zisi';
+};
+exports.getDefaultBundler = getDefaultBundler;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/node/bundlers/nft/es_modules.d.ts

@@ -1,11 +1,18 @@
 import { NodeFileTraceReasons } from '@vercel/nft';
 import type { FunctionConfig } from '../../../../config';
+import { FeatureFlags } from '../../../../feature_flags';
 import { FsCache } from '../../../../utils/fs';
-declare const transpileESM: ({ basePath, config, esmPaths, fsCache, reasons, }: {
+import { ModuleFormat } from '../../utils/module_format';
+declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }: {
     basePath: string | undefined;
     config: FunctionConfig;
     esmPaths: Set<string>;
+    featureFlags: FeatureFlags;
     fsCache: FsCache;
+    mainFile: string;
     reasons: NodeFileTraceReasons;
-}) => Promise<Map<string, string>>;
-export { transpileESM };
+}) => Promise<{
+    rewrites?: Map<string, string> | undefined;
+    moduleFormat: ModuleFormat;
+}>;
+export { processESM };

package/dist/runtimes/node/bundlers/nft/es_modules.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transpileESM = void 0;
+exports.processESM = void 0;
 const path_1 = require("path");
 const fs_1 = require("../../../../utils/fs");
+const node_version_1 = require("../../utils/node_version");
+const package_json_1 = require("../../utils/package_json");
 const transpile_1 = require("./transpile");
 const getPatchedESMPackages = async (packages, fsCache) => {
     const patchedPackages = await Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
@@ -12,6 +14,11 @@ const getPatchedESMPackages = async (packages, fsCache) => {
     });
     return patchedPackagesMap;
 };
+const isEntrypointESM = ({ basePath, esmPaths, mainFile, }) => {
+    const absoluteESMPaths = new Set([...esmPaths].map((path) => resolvePath(path, basePath)));
+    const entrypointIsESM = absoluteESMPaths.has(mainFile);
+    return entrypointIsESM;
+};
 const patchESMPackage = async (path, fsCache) => {
     const file = (await (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
     const packageJson = JSON.parse(file);
@@ -21,6 +28,28 @@ const patchESMPackage = async (path, fsCache) => {
     };
     return JSON.stringify(patchedPackageJson);
 };
+const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }) => {
+    const entrypointIsESM = isEntrypointESM({ basePath, esmPaths, mainFile });
+    if (!entrypointIsESM) {
+        return {
+            moduleFormat: 'cjs',
+        };
+    }
+    const packageJson = await (0, package_json_1.getPackageJsonIfAvailable)((0, path_1.dirname)(mainFile));
+    const nodeSupport = (0, node_version_1.getNodeSupportMatrix)(config.nodeVersion);
+    if (featureFlags.zisi_pure_esm && packageJson.type === 'module' && nodeSupport.esm) {
+        return {
+            moduleFormat: 'esm',
+        };
+    }
+    const rewrites = await transpileESM({ basePath, config, esmPaths, fsCache, reasons });
+    return {
+        moduleFormat: 'cjs',
+        rewrites,
+    };
+};
+exports.processESM = processESM;
+const resolvePath = (relativePath, basePath) => basePath ? (0, path_1.resolve)(basePath, relativePath) : (0, path_1.resolve)(relativePath);
 const shouldTranspile = (path, cache, esmPaths, reasons) => {
     if (cache.has(path)) {
         return cache.get(path);
@@ -33,15 +62,16 @@ const shouldTranspile = (path, cache, esmPaths, reasons) => {
         return false;
     }
     const { parents } = reason;
+    const parentPaths = [...parents].filter((parentPath) => parentPath !== path);
     // If the path is an entrypoint, we transpile it only if it's an ESM file.
-    if (parents.size === 0) {
+    if (parentPaths.length === 0) {
         const isESM = esmPaths.has(path);
         cache.set(path, isESM);
         return isESM;
     }
     // The path should be transpiled if every parent will also be transpiled, or
     // if there is no parent.
-    const shouldTranspilePath = [...parents].every((parentPath) => shouldTranspile(parentPath, cache, esmPaths, reasons));
+    const shouldTranspilePath = parentPaths.every((parentPath) => shouldTranspile(parentPath, cache, esmPaths, reasons));
     cache.set(path, shouldTranspilePath);
     return shouldTranspilePath;
 };
@@ -60,11 +90,10 @@ const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, }) =
         .map(([path]) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
     const rewrites = await getPatchedESMPackages(packageJsonPaths, fsCache);
     await Promise.all(pathsToTranspile.map(async (path) => {
-        const absolutePath = basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path);
+        const absolutePath = resolvePath(path, basePath);
         const transpiled = await (0, transpile_1.transpile)(absolutePath, config);
         rewrites.set(absolutePath, transpiled);
     }));
     return rewrites;
 };
-exports.transpileESM = transpileESM;
 //# sourceMappingURL=es_modules.js.map

package/dist/runtimes/node/bundlers/nft/index.js

@@ -15,12 +15,13 @@ const es_modules_1 = require("./es_modules");
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = async ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
+const bundle = async ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
-    const { paths: dependencyPaths, rewrites } = await traceFilesAndTranspile({
+    const { moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
         config,
+        featureFlags,
         mainFile,
         pluginsModulesPath,
     });
@@ -32,6 +33,7 @@ const bundle = async ({ basePath, config, mainFile, pluginsModulesPath, reposito
         basePath: (0, base_path_1.getBasePath)(dirnames),
         inputs: dependencyPaths,
         mainFile,
+        moduleFormat,
         rewrites,
         srcFiles,
     };
@@ -41,7 +43,7 @@ const ignoreFunction = (path) => {
     const shouldIgnore = ignore.some((expression) => (0, minimatch_1.default)(normalizedPath, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = async function ({ basePath, config, mainFile, pluginsModulesPath, }) {
+const traceFilesAndTranspile = async function ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, }) {
     const fsCache = {};
     const { fileList: dependencyPaths, esmFileList, reasons, } = await (0, nft_1.nodeFileTrace)([mainFile], {
         base: basePath,
@@ -75,8 +77,17 @@ const traceFilesAndTranspile = async function ({ basePath, config, mainFile, plu
         },
     });
     const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-    const rewrites = await (0, es_modules_1.transpileESM)({ basePath, config, esmPaths: esmFileList, fsCache, reasons });
+    const { moduleFormat, rewrites } = await (0, es_modules_1.processESM)({
+        basePath,
+        config,
+        esmPaths: esmFileList,
+        featureFlags,
+        fsCache,
+        mainFile,
+        reasons,
+    });
     return {
+        moduleFormat,
         paths: normalizedDependencyPaths,
         rewrites,
     };

package/dist/runtimes/node/bundlers/zisi/index.js

@@ -26,6 +26,7 @@ const bundle = async ({ basePath, config, extension, featureFlags, filename, mai
         basePath: (0, base_path_1.getBasePath)(dirnames),
         inputs: srcFiles,
         mainFile,
+        moduleFormat: 'cjs',
         srcFiles,
     };
 };

package/dist/runtimes/node/bundlers/zisi/list_imports.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/runtimes/node/bundlers/zisi/nested.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleModuleNotFound = exports.getNestedDependencies = void 0;
-const semver_1 = require("semver");
+const semver_1 = __importDefault(require("semver"));
 // Apply the Node.js module logic recursively on its own dependencies, using
 // the `package.json` `dependencies`, `peerDependencies` and
 // `optionalDependencies` keys
@@ -57,7 +60,8 @@ const isOptionalModule = function (moduleName, { optionalDependencies = {}, peer
             peerDependencies[moduleName] !== undefined));
 };
 const MIN_NEXT_VERSION = '10.0.4';
-const satisfiesRange = (range) => Boolean((0, semver_1.validRange)(range)) && ((0, semver_1.satisfies)(MIN_NEXT_VERSION, range) || (0, semver_1.ltr)(MIN_NEXT_VERSION, range));
+const satisfiesRange = (range) => Boolean(semver_1.default.validRange(range)) &&
+    (semver_1.default.satisfies(MIN_NEXT_VERSION, range) || semver_1.default.ltr(MIN_NEXT_VERSION, range));
 // 'critters' is used only in Next.js >= 10.0.4 when enabling an experimental option and has to be installed manually
 // we ignore it if it's missing
 const isExternalCrittersModule = function (moduleName, { dependencies = {}, devDependencies = {} }) {
@@ -70,8 +74,8 @@ const isExternalCrittersModule = function (moduleName, { dependencies = {}, devD
     }
     // can the declared Next.js version resolve to >=10.0.4 ?
     // test exact versions
-    if ((0, semver_1.valid)(nextVersion)) {
-        return (0, semver_1.gte)(nextVersion, MIN_NEXT_VERSION);
+    if (semver_1.default.valid(nextVersion)) {
+        return semver_1.default.gte(nextVersion, MIN_NEXT_VERSION);
     }
     return satisfiesRange(nextVersion);
 };

package/dist/runtimes/node/bundlers/zisi/resolve.js

@@ -4,11 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePathPreserveSymlinks = exports.resolvePackage = void 0;
+const module_1 = require("module");
 const process_1 = require("process");
 const find_up_1 = __importDefault(require("find-up"));
 const path_exists_1 = __importDefault(require("path-exists"));
 const resolve_1 = __importDefault(require("resolve"));
-const semver_1 = require("semver");
+const semver_1 = __importDefault(require("semver"));
+const requireLib = (0, module_1.createRequire)(__filename);
 const BACKSLASH_REGEXP = /\\/g;
 // Find the path to a module's `package.json`
 // We need to use `resolve` instead of `require.resolve()` because:
@@ -29,7 +31,7 @@ const resolvePackage = async function (moduleName, baseDirs) {
         return await resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs);
     }
     catch (error) {
-        if ((0, semver_1.lt)(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {
+        if (semver_1.default.lt(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {
             throw error;
         }
         try {
@@ -75,7 +77,7 @@ const resolvePathPreserveSymlinks = async function (path, baseDirs) {
 };
 exports.resolvePathPreserveSymlinks = resolvePathPreserveSymlinks;
 const resolvePathFollowSymlinks = function (path, baseDirs) {
-    return require.resolve(path, { paths: baseDirs });
+    return requireLib.resolve(path, { paths: baseDirs });
 };
 // `require.resolve()` on a module's specific file (like `package.json`)
 // can be forbidden by the package author by using an `exports` field in

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

@@ -1,4 +1,4 @@
 import { Runtime } from '../runtime';
-export declare type NodeBundlerName = 'esbuild' | 'esbuild_zisi' | 'nft' | 'zisi';
+export { NodeVersionString } from './utils/node_version';
 declare const runtime: Runtime;
 export default runtime;

package/dist/runtimes/node/index.js

@@ -8,33 +8,14 @@ const cp_file_1 = __importDefault(require("cp-file"));
 const bundlers_1 = require("./bundlers");
 const finder_1 = require("./finder");
 const in_source_config_1 = require("./in_source_config");
-const detect_es_module_1 = require("./utils/detect_es_module");
 const plugin_modules_path_1 = require("./utils/plugin_modules_path");
 const zip_1 = require("./utils/zip");
-// We use ZISI as the default bundler, except for certain extensions, for which
-// esbuild is the only option.
-const getDefaultBundler = async ({ extension, mainFile, featureFlags, }) => {
-    const { defaultEsModulesToEsbuild, traceWithNft } = featureFlags;
-    if (['.mjs', '.ts'].includes(extension)) {
-        return 'esbuild';
-    }
-    if (traceWithNft) {
-        return 'nft';
-    }
-    if (defaultEsModulesToEsbuild) {
-        const isEsModule = await (0, detect_es_module_1.detectEsModule)({ mainFile });
-        if (isEsModule) {
-            return 'esbuild';
-        }
-    }
-    return 'zisi';
-};
 // A proxy for the `getSrcFiles` function which adds a default `bundler` using
 // the `getDefaultBundler` function.
 const getSrcFilesWithBundler = async (parameters) => {
     const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(parameters.srcDir);
     const bundlerName = parameters.config.nodeBundler ||
-        (await getDefaultBundler({
+        (await (0, bundlers_1.getDefaultBundler)({
             extension: parameters.extension,
             featureFlags: parameters.featureFlags,
             mainFile: parameters.mainFile,
@@ -44,7 +25,7 @@ const getSrcFilesWithBundler = async (parameters) => {
 };
 const zipFunction = async function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
     const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(srcDir);
-    const bundlerName = config.nodeBundler || (await getDefaultBundler({ extension, mainFile, featureFlags }));
+    const bundlerName = config.nodeBundler || (await (0, bundlers_1.getDefaultBundler)({ extension, mainFile, featureFlags }));
     const bundler = (0, bundlers_1.getBundler)(bundlerName);
     // 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.
@@ -53,7 +34,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         await (0, cp_file_1.default)(srcPath, destPath);
         return { config, path: destPath };
     }
-    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
+    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
         basePath,
         config,
         extension,
@@ -78,6 +59,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         extension,
         filename,
         mainFile: finalMainFile,
+        moduleFormat,
         rewrites,
         srcFiles,
     });

package/dist/runtimes/node/utils/entry_file.d.ts

@@ -0,0 +1,13 @@
+import type { ModuleFormat } from './module_format';
+interface EntryFile {
+    contents: string;
+    filename: string;
+}
+declare const getEntryFile: ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }: {
+    commonPrefix: string;
+    filename: string;
+    mainFile: string;
+    moduleFormat: ModuleFormat;
+    userNamespace: string;
+}) => EntryFile;
+export { EntryFile, getEntryFile };

package/dist/runtimes/node/utils/entry_file.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryFile = void 0;
+const path_1 = require("path");
+const normalize_path_1 = require("./normalize_path");
+const getEntryFileContents = (mainPath, moduleFormat) => {
+    const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
+    if (moduleFormat === 'cjs') {
+        return `module.exports = require('${importPath}')`;
+    }
+    return `export { handler } from '${importPath}'`;
+};
+const getEntryFile = ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }) => {
+    const mainPath = (0, normalize_path_1.normalizeFilePath)({ commonPrefix, path: mainFile, userNamespace });
+    const extension = (0, path_1.extname)(filename);
+    const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
+    const contents = getEntryFileContents(mainPath, moduleFormat);
+    return {
+        contents,
+        filename: entryFilename,
+    };
+};
+exports.getEntryFile = getEntryFile;
+//# sourceMappingURL=entry_file.js.map

package/dist/runtimes/node/utils/module_format.d.ts

@@ -0,0 +1 @@
+export declare type ModuleFormat = 'cjs' | 'esm';

package/dist/runtimes/node/utils/module_format.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=module_format.js.map

package/dist/runtimes/node/utils/node_version.d.ts

@@ -0,0 +1,10 @@
+declare type SupportedVersionNumbers = 8 | 10 | 12 | 14;
+declare type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+interface NodeVersionSupport {
+    esm: boolean;
+}
+declare const DEFAULT_NODE_VERSION = 14;
+declare const getNodeVersion: (configVersion?: string | undefined) => number;
+declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
+declare const parseVersion: (input: string | undefined) => number | undefined;
+export { DEFAULT_NODE_VERSION, getNodeSupportMatrix, getNodeVersion, NodeVersionString, NodeVersionSupport, parseVersion, };

package/dist/runtimes/node/utils/node_version.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersion = exports.getNodeVersion = exports.getNodeSupportMatrix = exports.DEFAULT_NODE_VERSION = void 0;
+// Must match the default version used in Bitballoon.
+const DEFAULT_NODE_VERSION = 14;
+exports.DEFAULT_NODE_VERSION = DEFAULT_NODE_VERSION;
+const VERSION_REGEX = /(nodejs)?(\d+)\.x/;
+const getNodeVersion = (configVersion) => { var _a; return (_a = parseVersion(configVersion)) !== null && _a !== void 0 ? _a : DEFAULT_NODE_VERSION; };
+exports.getNodeVersion = getNodeVersion;
+const getNodeSupportMatrix = (configVersion) => {
+    const versionNumber = getNodeVersion(configVersion);
+    return {
+        esm: versionNumber >= 14,
+    };
+};
+exports.getNodeSupportMatrix = getNodeSupportMatrix;
+// Takes a string in the format defined by the `NodeVersion` type and returns
+// the numeric major version (e.g. "nodejs14.x" => 14).
+const parseVersion = (input) => {
+    if (input === undefined) {
+        return;
+    }
+    const match = input.match(VERSION_REGEX);
+    if (match === null) {
+        return;
+    }
+    const version = Number.parseInt(match[2]);
+    if (Number.isNaN(version)) {
+        return;
+    }
+    return version;
+};
+exports.parseVersion = parseVersion;
+/* eslint-enable no-magic-numbers */
+//# sourceMappingURL=node_version.js.map

package/dist/runtimes/node/utils/normalize_path.d.ts

@@ -0,0 +1,6 @@
+declare const normalizeFilePath: ({ commonPrefix, path, userNamespace, }: {
+    commonPrefix: string;
+    path: string;
+    userNamespace: string;
+}) => string;
+export { normalizeFilePath };

package/dist/runtimes/node/utils/normalize_path.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFilePath = void 0;
+const path_1 = require("path");
+const unixify_1 = __importDefault(require("unixify"));
+// `adm-zip` and `require()` expect Unix paths.
+// We remove the common path prefix.
+// With files on different Windows drives, we remove the drive letter.
+const normalizeFilePath = function ({ commonPrefix, path, userNamespace, }) {
+    const userNamespacePathSegment = userNamespace ? `${userNamespace}${path_1.sep}` : '';
+    const pathA = (0, path_1.normalize)(path);
+    const pathB = pathA.replace(commonPrefix, userNamespacePathSegment);
+    const pathC = (0, unixify_1.default)(pathB);
+    return pathC;
+};
+exports.normalizeFilePath = normalizeFilePath;
+//# sourceMappingURL=normalize_path.js.map

package/dist/runtimes/node/utils/package_json.d.ts

@@ -15,4 +15,5 @@ interface PackageJson {
 }
 declare const sanitisePackageJson: (packageJson: Record<string, unknown>) => PackageJson;
 declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
-export { getPackageJson, PackageJson, sanitisePackageJson };
+declare const getPackageJsonIfAvailable: (srcDir: string) => Promise<PackageJson>;
+export { getPackageJson, getPackageJsonIfAvailable, PackageJson, sanitisePackageJson };

package/dist/runtimes/node/utils/package_json.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitisePackageJson = exports.getPackageJson = void 0;
+exports.sanitisePackageJson = exports.getPackageJsonIfAvailable = exports.getPackageJson = void 0;
 const pkg_dir_1 = __importDefault(require("pkg-dir"));
 const sanitiseFiles = (files) => {
     if (!Array.isArray(files)) {
@@ -34,4 +34,14 @@ const getPackageJson = async function (srcDir) {
     }
 };
 exports.getPackageJson = getPackageJson;
+const getPackageJsonIfAvailable = async (srcDir) => {
+    try {
+        const packageJson = await getPackageJson(srcDir);
+        return packageJson;
+    }
+    catch {
+        return {};
+    }
+};
+exports.getPackageJsonIfAvailable = getPackageJsonIfAvailable;
 //# sourceMappingURL=package_json.js.map

package/dist/runtimes/node/utils/zip.d.ts

@@ -1,3 +1,4 @@
+import type { ModuleFormat } from './module_format';
 declare type ArchiveFormat = 'none' | 'zip';
 interface ZipNodeParameters {
     aliases?: Map<string, string>;
@@ -6,6 +7,7 @@ interface ZipNodeParameters {
     extension: string;
     filename: string;
     mainFile: string;
+    moduleFormat: ModuleFormat;
     rewrites?: Map<string, string>;
     srcFiles: string[];
 }

package/dist/runtimes/node/utils/zip.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zipNodeJs = void 0;
-/* eslint-disable max-lines */
 const buffer_1 = require("buffer");
 const fs_1 = require("fs");
 const os_1 = __importDefault(require("os"));
@@ -12,19 +11,21 @@ const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
 const del_1 = __importDefault(require("del"));
 const p_map_1 = __importDefault(require("p-map"));
-const unixify_1 = __importDefault(require("unixify"));
 const archive_1 = require("../../../archive");
 const fs_2 = require("../../../utils/fs");
+const entry_file_1 = require("./entry_file");
+const normalize_path_1 = require("./normalize_path");
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os_1.default.cpus().length === 0 ? 2 : os_1.default.cpus().length * 2;
 // Sub-directory to place all user-defined files  (i.e. everything other than
 // the entry file generated by zip-it-and-ship-it).
 const DEFAULT_USER_SUBDIRECTORY = 'src';
-const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, rewrites = new Map(), srcFiles, }) {
-    const { contents: entryContents, filename: entryFilename } = getEntryFile({
+const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, moduleFormat, rewrites = new Map(), srcFiles, }) {
+    const { contents: entryContents, filename: entryFilename } = (0, entry_file_1.getEntryFile)({
         commonPrefix: basePath,
         filename,
         mainFile,
+        moduleFormat,
         userNamespace: DEFAULT_USER_SUBDIRECTORY,
     });
     const functionFolder = (0, path_1.join)(destFolder, (0, path_1.basename)(filename, extension));
@@ -36,7 +37,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
     // Copying source files.
     await (0, p_map_1.default)(srcFiles, (srcFile) => {
         const destPath = aliases.get(srcFile) || srcFile;
-        const normalizedDestPath = normalizeFilePath({
+        const normalizedDestPath = (0, normalize_path_1.normalizeFilePath)({
             commonPrefix: basePath,
             path: destPath,
             userNamespace: DEFAULT_USER_SUBDIRECTORY,
@@ -49,7 +50,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
     }, { concurrency: COPY_FILE_CONCURRENCY });
     return functionFolder;
 };
-const createZipArchive = async function ({ aliases, basePath, destFolder, extension, filename, mainFile, rewrites, srcFiles, }) {
+const createZipArchive = async function ({ aliases, basePath, destFolder, extension, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
     const destPath = (0, path_1.join)(destFolder, `${(0, path_1.basename)(filename, extension)}.zip`);
     const { archive, output } = (0, archive_1.startZip)(destPath);
     const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
@@ -65,7 +66,7 @@ const createZipArchive = async function ({ aliases, basePath, destFolder, extens
     // than the entry file) to its own sub-directory.
     const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : '';
     if (needsEntryFile) {
-        const entryFile = getEntryFile({ commonPrefix: basePath, filename, mainFile, userNamespace });
+        const entryFile = (0, entry_file_1.getEntryFile)({ commonPrefix: basePath, filename, mainFile, moduleFormat, userNamespace });
         addEntryFileToZip(archive, entryFile);
     }
     const srcFilesInfos = await Promise.all(srcFiles.map(addStat));
@@ -100,18 +101,9 @@ const addStat = async function (srcFile) {
     const stat = await fs_1.promises.lstat(srcFile);
     return { srcFile, stat };
 };
-const getEntryFile = ({ commonPrefix, filename, mainFile, userNamespace, }) => {
-    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
-    const extension = (0, path_1.extname)(filename);
-    const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
-    return {
-        contents: `module.exports = require('.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}')`,
-        filename: entryFilename,
-    };
-};
 const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrites = new Map(), stat, srcFile, userNamespace, }) {
     const destPath = aliases.get(srcFile) || srcFile;
-    const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, userNamespace });
+    const normalizedDestPath = (0, normalize_path_1.normalizeFilePath)({ commonPrefix, path: destPath, userNamespace });
     if (rewrites.has(srcFile)) {
         (0, archive_1.addZipContent)(archive, rewrites.get(srcFile), normalizedDestPath);
     }
@@ -119,15 +111,4 @@ const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrit
         (0, archive_1.addZipFile)(archive, srcFile, normalizedDestPath, stat);
     }
 };
-// `adm-zip` and `require()` expect Unix paths.
-// We remove the common path prefix.
-// With files on different Windows drives, we remove the drive letter.
-const normalizeFilePath = function ({ commonPrefix, path, userNamespace, }) {
-    const userNamespacePathSegment = userNamespace ? `${userNamespace}${path_1.sep}` : '';
-    const pathA = (0, path_1.normalize)(path);
-    const pathB = pathA.replace(commonPrefix, userNamespacePathSegment);
-    const pathC = (0, unixify_1.default)(pathB);
-    return pathC;
-};
-/* eslint-enable max-lines */
 //# sourceMappingURL=zip.js.map

package/dist/runtimes/runtime.d.ts

@@ -3,7 +3,7 @@ import { FunctionConfig } from '../config';
 import { FeatureFlags } from '../feature_flags';
 import { FunctionSource, SourceFile } from '../function';
 import { FsCache } from '../utils/fs';
-import type { NodeBundlerName } from './node';
+import type { NodeBundlerName } from './node/bundlers';
 import type { ISCValues } from './node/in_source_config';
 declare type RuntimeName = 'go' | 'js' | 'rs';
 declare type FindFunctionsInPathsFunction = (args: {

package/dist/runtimes/rust/builder.js

@@ -38,7 +38,7 @@ const build = async ({ config, name, srcDir }) => {
 exports.build = build;
 const cargoBuild = async ({ functionName, srcDir, targetDirectory, }) => {
     try {
-        await (0, shell_1.runCommand)('cargo', ['build', '--target', constants_1.BUILD_TARGET, '--release'], {
+        await shell_1.shellUtils.runCommand('cargo', ['build', '--target', constants_1.BUILD_TARGET, '--release'], {
             cwd: srcDir,
             env: {
                 CARGO_TARGET_DIR: targetDirectory,
@@ -60,7 +60,7 @@ const cargoBuild = async ({ functionName, srcDir, targetDirectory, }) => {
 };
 const checkRustToolchain = async () => {
     try {
-        await (0, shell_1.runCommand)('cargo', ['-V']);
+        await shell_1.shellUtils.runCommand('cargo', ['-V']);
         return true;
     }
     catch {
@@ -86,8 +86,8 @@ let toolchainInstallation;
 // `BUILD_TARGET`. The Promise is saved to `toolchainInstallation`, so
 // that we run the command just once for multiple Rust functions.
 const installToolchain = async () => {
-    await (0, shell_1.runCommand)('rustup', ['default', 'stable']);
-    await (0, shell_1.runCommand)('rustup', ['target', 'add', constants_1.BUILD_TARGET]);
+    await shell_1.shellUtils.runCommand('rustup', ['default', 'stable']);
+    await shell_1.shellUtils.runCommand('rustup', ['target', 'add', constants_1.BUILD_TARGET]);
 };
 const installToolchainOnce = () => {
     if (toolchainInstallation === undefined) {

package/dist/utils/shell.d.ts

@@ -1,2 +1,22 @@
+/// <reference types="node" />
 import execa from 'execa';
-export { execa as runCommand };
+export declare const shellUtils: {
+    runCommand: {
+        (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        (file: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        (file: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        sync(file: string, arguments?: readonly string[] | undefined, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
+        sync(file: string, arguments?: readonly string[] | undefined, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
+        sync(file: string, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
+        sync(file: string, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
+        command(command: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        command(command: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        commandSync(command: string, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
+        commandSync(command: string, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
+        node(scriptPath: string, arguments?: readonly string[] | undefined, options?: execa.NodeOptions<string> | undefined): execa.ExecaChildProcess<string>;
+        node(scriptPath: string, arguments?: readonly string[] | undefined, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        node(scriptPath: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        node(scriptPath: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+    };
+};

package/dist/utils/shell.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCommand = void 0;
+exports.shellUtils = void 0;
 const execa_1 = __importDefault(require("execa"));
-exports.runCommand = execa_1.default;
+exports.shellUtils = { runCommand: execa_1.default };
 //# sourceMappingURL=shell.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.5.2",
+  "version": "5.7.2",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -29,8 +29,8 @@
     "test:ci": "npm run build && c8 -r lcovonly -r text -r json ava"
   },
   "config": {
-    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,tests,.github}/**/*.{js,ts,md,html}\" \"*.{js,ts,md,html}\" \".*.{js,ts,md,html}\"",
-    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tests,.github}/**/*.{js,ts,md,yml,json,html}\" \"*.{js,ts,yml,json,html}\" \".*.{js,ts,yml,json,html}\" \"!package-lock.json\""
+    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,tests,.github}/**/*.{mjs,cjs,js,mts,cts,ts,md,html}\" \"*.{cjs,mjs,js,cts,mts,ts,md,html}\" \".*.{cjs,mjs,js,cts,mts,ts,md,html}\"",
+    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tests,.github}/**/*.{cjs,mjs,js,cts,mts,ts,md,yml,json,html}\" \"*.{cjs,mjs,js,cts,mts,ts,yml,json,html}\" \".*.{cjs,mjs,js,cts,mts,ts,yml,json,html}\" \"!package-lock.json\""
   },
   "eslintIgnore": [
     "benchmarks/fixtures/**"
@@ -81,13 +81,13 @@
     "semver": "^7.0.0",
     "tmp-promise": "^3.0.2",
     "toml": "^3.0.0",
-    "typescript": "^4.4.3",
+    "typescript": "^4.6.0-beta",
     "unixify": "^1.0.0",
     "yargs": "^16.0.0"
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^4.1.7",
+    "@netlify/eslint-config-node": "^5.1.4",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",
@@ -102,7 +102,7 @@
     "husky": "^7.0.4",
     "npm-run-all": "^4.1.5",
     "p-every": "^2.0.0",
-    "sinon": "^12.0.0",
+    "sinon": "^13.0.0",
     "sort-on": "^4.1.1",
     "source-map-support": "^0.5.20",
     "throat": "^6.0.1"
@@ -112,7 +112,8 @@
   },
   "ava": {
     "files": [
-      "tests/*"
+      "tests/*",
+      "tests/unit/**/*.js"
     ],
     "verbose": true,
     "timeout": "2m"