@netlify/zip-it-and-ship-it 6.0.0 → 7.1.0

package/README.md

@@ -51,9 +51,8 @@ In Netlify, this directory is the
 
 A source folder can contain:
 
-- Sub-directories with a main file called `index.js`, `index.ts`, `{dir}.js` or `{dir}.ts` where `{dir}` is the
-  sub-directory name.
-- `.js` or `.ts` files (Node.js)
+- Sub-directories with a main file called `index.js` or `{dir}.js` where `{dir}` is the sub-directory name.
+- `.js`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts` or `.cts` files (Node.js)
 - `.zip` archives with Node.js already ready to upload to AWS Lambda.
 - Go programs already compiled. Those are copied as is.
 - Rust programs already compiled. Those are zipped.

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import type { FeatureFlags } from './feature_flags.js';
 import { FunctionSource } from './function.js';
 import type { NodeBundlerType } from './runtimes/node/bundlers/types.js';
 import type { NodeVersionString } from './runtimes/node/index.js';
+import type { ModuleFormat } from './runtimes/node/utils/module_format.js';
 interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
@@ -14,6 +15,7 @@ interface FunctionConfig {
     rustTargetDirectory?: string;
     schedule?: string;
     zipGo?: boolean;
+    nodeModuleFormat?: ModuleFormat;
 }
 declare type GlobPattern = string;
 declare type Config = Record<GlobPattern, FunctionConfig>;

package/dist/feature_flags.d.ts

@@ -1,4 +1,4 @@
 export declare const defaultFlags: Record<string, boolean>;
 export declare type FeatureFlag = keyof typeof defaultFlags;
 export declare type FeatureFlags = Record<FeatureFlag, boolean>;
-export declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => {};
+export declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => FeatureFlags;

package/dist/feature_flags.js

@@ -3,10 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFlags = exports.defaultFlags = void 0;
 const process_1 = require("process");
 exports.defaultFlags = {
+    // Build Rust functions from source.
     buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
+    // Use esbuild to trace dependencies in the legacy bundler.
     parseWithEsbuild: false,
+    // Use NFT as the default bundler.
     traceWithNft: false,
+    // Output pure (i.e. untranspiled) ESM files when the function file has ESM
+    // syntax and the parent `package.json` file has `{"type": "module"}`.
     zisi_pure_esm: false,
+    // Output pure (i.e. untranspiled) ESM files when the function file has a
+    // `.mjs` extension.
+    zisi_pure_esm_mjs: false,
+    // Load configuration from per-function JSON files.
     project_deploy_configuration_api_use_per_function_configuration_files: false,
 };
 // List of supported flags and their default value.

package/dist/main.d.ts

@@ -21,14 +21,14 @@ interface ListFunctionsOptions {
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
-export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunction: (path: string, { featureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction | undefined>;
-export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
+export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;

package/dist/runtimes/node/bundlers/esbuild/bundler.d.ts

@@ -1,13 +1,15 @@
 import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
+import { ModuleFileExtension, ModuleFormat } from '../../utils/module_format.js';
 export declare const ESBUILD_LOG_LIMIT = 10;
-export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, featureFlags, ignoredModules, name, srcDir, srcFile, }: {
+export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, featureFlags, ignoredModules, mainFile, name, srcDir, srcFile, }: {
     additionalModulePaths?: string[] | undefined;
     basePath?: string | undefined;
     config: FunctionConfig;
     externalModules: string[];
     featureFlags: FeatureFlags;
     ignoredModules: string[];
+    mainFile: string;
     name: string;
     srcDir: string;
     srcFile: string;
@@ -15,8 +17,9 @@ export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, e
     additionalPaths: string[];
     bundlePaths: Map<string, string>;
     cleanTempFiles: () => Promise<void>;
+    extension: ModuleFileExtension;
     inputs: string[];
-    moduleFormat: import("../../utils/module_format.js").ModuleFormat;
+    moduleFormat: ModuleFormat;
     nativeNodeModules: {};
     nodeModulesWithDynamicImports: string[];
     warnings: import("@netlify/esbuild").Message[];

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

@@ -6,6 +6,7 @@ const esbuild_1 = require("@netlify/esbuild");
 const tmp_promise_1 = require("tmp-promise");
 const error_js_1 = require("../../../../utils/error.js");
 const fs_js_1 = require("../../../../utils/fs.js");
+const module_format_js_1 = require("../../utils/module_format.js");
 const bundler_target_js_1 = require("./bundler_target.js");
 const plugin_dynamic_imports_js_1 = require("./plugin_dynamic_imports.js");
 const plugin_native_modules_js_1 = require("./plugin_native_modules.js");
@@ -16,9 +17,9 @@ const plugin_node_builtin_js_1 = require("./plugin_node_builtin.js");
 exports.ESBUILD_LOG_LIMIT = 10;
 // When resolving imports with no extension (e.g. require('./foo')), these are
 // the extensions that esbuild will look for, in this order.
-const RESOLVE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.json'];
+const RESOLVE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts', '.json'];
 // eslint-disable-next-line max-statements
-const bundleJsFile = async function ({ additionalModulePaths, basePath, config, externalModules = [], featureFlags, ignoredModules = [], name, srcDir, srcFile, }) {
+const bundleJsFile = async function ({ additionalModulePaths, basePath, config, externalModules = [], featureFlags, ignoredModules = [], mainFile, name, srcDir, srcFile, }) {
     // We use a temporary directory as the destination for esbuild files to avoid
     // any naming conflicts with files generated by other functions.
     const targetDirectory = await (0, tmp_promise_1.tmpName)();
@@ -56,7 +57,11 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
     // Configuring the output format of esbuild. The `includedFiles` array we get
     // here contains additional paths to include with the bundle, like the path
     // to a `package.json` with {"type": "module"} in case of an ESM function.
-    const { includedFiles: includedFilesFromModuleDetection, moduleFormat } = await (0, bundler_target_js_1.getModuleFormat)(srcDir, featureFlags, config.nodeVersion);
+    const { includedFiles: includedFilesFromModuleDetection, moduleFormat } = await (0, bundler_target_js_1.getModuleFormat)(srcDir, featureFlags, (0, path_1.extname)(mainFile), config.nodeVersion);
+    // The extension of the output file.
+    const extension = (0, module_format_js_1.getFileExtensionForFormat)(moduleFormat, featureFlags);
+    // When outputting an ESM file, configure esbuild to produce a `.mjs` file.
+    const outExtension = moduleFormat === "esm" /* ModuleFormat.ESM */ ? { [".js" /* ModuleFileExtension.JS */]: ".mjs" /* ModuleFileExtension.MJS */ } : undefined;
     try {
         const { metafile = { inputs: {}, outputs: {} }, warnings } = await (0, esbuild_1.build)({
             bundle: true,
@@ -67,6 +72,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
             logLimit: exports.ESBUILD_LOG_LIMIT,
             metafile: true,
             nodePaths: additionalModulePaths,
+            outExtension,
             outdir: targetDirectory,
             platform: 'node',
             plugins,
@@ -77,6 +83,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
         });
         const bundlePaths = getBundlePaths({
             destFolder: targetDirectory,
+            extension,
             outputs: metafile.outputs,
             srcFile,
         });
@@ -87,6 +94,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
             additionalPaths,
             bundlePaths,
             cleanTempFiles,
+            extension,
             inputs,
             moduleFormat,
             nativeNodeModules,
@@ -107,8 +115,8 @@ exports.bundleJsFile = bundleJsFile;
 // absolute paths of the generated files as keys, and the paths that those
 // files should take in the generated bundle as values. This is compatible
 // with the `aliases` format used upstream.
-const getBundlePaths = ({ destFolder, outputs, srcFile, }) => {
-    const bundleFilename = `${(0, path_1.basename)(srcFile, (0, path_1.extname)(srcFile))}.js`;
+const getBundlePaths = ({ destFolder, extension: outputExtension, outputs, srcFile, }) => {
+    const bundleFilename = (0, path_1.basename)(srcFile, (0, path_1.extname)(srcFile)) + outputExtension;
     const mainFileDirectory = (0, path_1.dirname)(srcFile);
     const bundlePaths = new Map();
     // The paths returned by esbuild are relative to the current directory, which
@@ -121,11 +129,11 @@ const getBundlePaths = ({ destFolder, outputs, srcFile, }) => {
         const extension = (0, path_1.extname)(path);
         const absolutePath = (0, path_1.join)(destFolder, filename);
         if (output.entryPoint && (0, path_1.basename)(output.entryPoint) === (0, path_1.basename)(srcFile)) {
-            // Ensuring the main file has a `.js` extension.
-            const normalizedSrcFile = (0, fs_js_1.getPathWithExtension)(srcFile, '.js');
+            // Ensuring the main file has the right extension.
+            const normalizedSrcFile = (0, fs_js_1.getPathWithExtension)(srcFile, outputExtension);
             bundlePaths.set(absolutePath, normalizedSrcFile);
         }
-        else if (extension === '.js' || filename === `${bundleFilename}.map`) {
+        else if (extension === outputExtension || filename === `${bundleFilename}.map`) {
             bundlePaths.set(absolutePath, (0, path_1.join)(mainFileDirectory, filename));
         }
     });

package/dist/runtimes/node/bundlers/esbuild/bundler_target.d.ts

@@ -10,7 +10,7 @@ declare const versionMap: {
 };
 declare type VersionValues = typeof versionMap[keyof typeof versionMap];
 declare const getBundlerTarget: (suppliedVersion?: NodeVersionString) => VersionValues;
-declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, configVersion?: string) => Promise<{
+declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, extension: string, configVersion?: string) => Promise<{
     includedFiles: string[];
     moduleFormat: ModuleFormat;
 }>;

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

@@ -18,7 +18,13 @@ const getBundlerTarget = (suppliedVersion) => {
     return versionMap[`${node_version_1.DEFAULT_NODE_VERSION}.x`];
 };
 exports.getBundlerTarget = getBundlerTarget;
-const getModuleFormat = async (srcDir, featureFlags, configVersion) => {
+const getModuleFormat = async (srcDir, featureFlags, extension, configVersion) => {
+    if (extension === ".mjs" /* ModuleFileExtension.MJS */ && featureFlags.zisi_pure_esm_mjs) {
+        return {
+            includedFiles: [],
+            moduleFormat: "esm" /* ModuleFormat.ESM */,
+        };
+    }
     const packageJsonFile = await (0, package_json_1.getClosestPackageJson)(srcDir);
     const nodeSupport = (0, node_version_1.getNodeSupportMatrix)(configVersion);
     if (featureFlags.zisi_pure_esm && (packageJsonFile === null || packageJsonFile === void 0 ? void 0 : packageJsonFile.contents.type) === 'module' && nodeSupport.esm) {

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

@@ -30,13 +30,14 @@ const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
 };
 const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => {
     const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await (0, bundler_js_1.bundleJsFile)({
+    const { additionalPaths, bundlePaths, cleanTempFiles, extension: outputExtension, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await (0, bundler_js_1.bundleJsFile)({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
         basePath,
         config,
         externalModules,
         featureFlags,
         ignoredModules,
+        mainFile,
         name,
         srcDir,
         srcFile: mainFile,
@@ -65,7 +66,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
     // 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 = (0, fs_js_1.getPathWithExtension)(mainFile, '.js');
+    const normalizedMainFile = (0, fs_js_1.getPathWithExtension)(mainFile, outputExtension);
     const functionBasePath = getFunctionBasePath({
         basePathFromConfig: basePath,
         mainFile,

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBundlerName = exports.getBundler = void 0;
+const path_1 = require("path");
 const detect_es_module_js_1 = require("../utils/detect_es_module.js");
 const index_js_1 = __importDefault(require("./esbuild/index.js"));
 const index_js_2 = __importDefault(require("./nft/index.js"));
@@ -32,16 +33,20 @@ const getBundlerName = async ({ config: { nodeBundler }, extension, featureFlags
     return await getDefaultBundler({ extension, featureFlags, mainFile });
 };
 exports.getBundlerName = getBundlerName;
+const ESBUILD_EXTENSIONS = new Set(['.mjs', '.ts', '.tsx', '.cts', '.mts']);
 // We use ZISI as the default bundler, except for certain extensions, for which
 // esbuild is the only option.
 const getDefaultBundler = async ({ extension, featureFlags, mainFile, }) => {
-    if (['.mjs', '.ts'].includes(extension)) {
+    if (extension === ".mjs" /* ModuleFileExtension.MJS */ && featureFlags.zisi_pure_esm_mjs) {
+        return "nft" /* NodeBundlerType.NFT */;
+    }
+    if (ESBUILD_EXTENSIONS.has(extension)) {
         return "esbuild" /* NodeBundlerType.ESBUILD */;
     }
     if (featureFlags.traceWithNft) {
         return "nft" /* NodeBundlerType.NFT */;
     }
-    const functionIsESM = await (0, detect_es_module_js_1.detectEsModule)({ mainFile });
+    const functionIsESM = (0, path_1.extname)(mainFile) !== ".cjs" /* ModuleFileExtension.CJS */ && (await (0, detect_es_module_js_1.detectEsModule)({ mainFile }));
     return functionIsESM ? "nft" /* NodeBundlerType.NFT */ : "zisi" /* NodeBundlerType.ZISI */;
 };
 //# sourceMappingURL=index.js.map

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

@@ -29,6 +29,14 @@ const patchESMPackage = async (path, fsCache) => {
     return JSON.stringify(patchedPackageJson);
 };
 const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, name, }) => {
+    const extension = (0, path_1.extname)(mainFile);
+    // If this is a .mjs file and we want to output pure ESM files, we don't need
+    // to transpile anything.
+    if (extension === ".mjs" /* ModuleFileExtension.MJS */ && featureFlags.zisi_pure_esm_mjs) {
+        return {
+            moduleFormat: "esm" /* ModuleFormat.ESM */,
+        };
+    }
     const entrypointIsESM = isEntrypointESM({ basePath, esmPaths, mainFile });
     if (!entrypointIsESM) {
         return {

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

@@ -4,13 +4,11 @@ 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 = __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:
@@ -77,7 +75,7 @@ const resolvePathPreserveSymlinks = async function (path, baseDirs) {
 };
 exports.resolvePathPreserveSymlinks = resolvePathPreserveSymlinks;
 const resolvePathFollowSymlinks = function (path, baseDirs) {
-    return requireLib.resolve(path, { paths: baseDirs });
+    return require.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/bundlers/zisi/src_files.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSrcFiles = void 0;
-/* eslint-disable max-lines */
 const path_1 = require("path");
 const junk_1 = require("junk");
 const precinct_1 = __importDefault(require("precinct"));
@@ -114,5 +113,4 @@ const getTreeShakedDependencies = async function ({ dependency, basedir, feature
     });
     return [path, ...depsPath];
 };
-/* eslint-enable max-lines */
 //# sourceMappingURL=src_files.js.map

package/dist/runtimes/node/finder.js

@@ -9,7 +9,7 @@ const path_1 = require("path");
 const locate_path_1 = __importDefault(require("locate-path"));
 const non_nullable_js_1 = require("../../utils/non_nullable.js");
 // List of extensions that this runtime will look for, in order of precedence.
-const allowedExtensions = ['.js', '.zip', '.cjs', '.mjs', '.ts'];
+const allowedExtensions = ['.js', '.zip', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts'];
 // Sorting function, compatible with the callback of Array.sort, which sorts
 // entries by extension according to their position in `allowedExtensions`.
 // It places extensions with a higher precedence last in the array, so that
@@ -64,8 +64,16 @@ const getMainFile = async function (srcPath, filename, stat) {
             (0, path_1.join)(srcPath, 'index.js'),
             (0, path_1.join)(srcPath, `${filename}.mjs`),
             (0, path_1.join)(srcPath, 'index.mjs'),
+            (0, path_1.join)(srcPath, `${filename}.cjs`),
+            (0, path_1.join)(srcPath, 'index.cjs'),
             (0, path_1.join)(srcPath, `${filename}.ts`),
             (0, path_1.join)(srcPath, 'index.ts'),
+            (0, path_1.join)(srcPath, `${filename}.tsx`),
+            (0, path_1.join)(srcPath, 'index.tsx'),
+            (0, path_1.join)(srcPath, `${filename}.mts`),
+            (0, path_1.join)(srcPath, 'index.mts'),
+            (0, path_1.join)(srcPath, `${filename}.cts`),
+            (0, path_1.join)(srcPath, 'index.cts'),
         ], { type: 'file' });
     }
     const extension = (0, path_1.extname)(srcPath);

package/dist/runtimes/node/index.js

@@ -63,6 +63,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         basePath: finalBasePath,
         destFolder,
         extension,
+        featureFlags,
         filename,
         mainFile: finalMainFile,
         moduleFormat,

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

@@ -1,4 +1,4 @@
-export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
+export declare const parseExpression: ({ basePath, expression, resolveDir, }: {
     basePath: string;
     expression: string;
     resolveDir: string;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.safelyParseFile = exports.parseExpression = void 0;
-/* eslint-disable max-lines */
 const fs_1 = require("fs");
 const path_1 = require("path");
 const parser_1 = require("@babel/parser");
@@ -170,5 +169,4 @@ const validateGlobNodes = (globNodes) => {
     const hasStaticHead = globNodes[0] !== GLOB_WILDCARD;
     return hasStrings && hasStaticHead;
 };
-/* eslint-enable max-lines */
 //# sourceMappingURL=index.js.map

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

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

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

@@ -1,24 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEntryFile = void 0;
-const path_1 = require("path");
 const normalize_path_js_1 = require("./normalize_path.js");
-const getEntryFileContents = (mainPath, moduleFormat) => {
+const getEntryFile = ({ commonPrefix, mainFile, moduleFormat, userNamespace, }) => {
+    const mainPath = (0, normalize_path_js_1.normalizeFilePath)({ commonPrefix, path: mainFile, userNamespace });
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
     if (moduleFormat === "cjs" /* ModuleFormat.COMMONJS */) {
         return `module.exports = require('${importPath}')`;
     }
     return `export { handler } from '${importPath}'`;
 };
-const getEntryFile = ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }) => {
-    const mainPath = (0, normalize_path_js_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

@@ -1,4 +1,11 @@
+import type { FeatureFlags } from '../../../feature_flags.js';
 export declare const enum ModuleFormat {
     COMMONJS = "cjs",
     ESM = "esm"
 }
+export declare const enum ModuleFileExtension {
+    CJS = ".cjs",
+    JS = ".js",
+    MJS = ".mjs"
+}
+export declare const getFileExtensionForFormat: (moduleFormat: ModuleFormat, featureFlags: FeatureFlags) => ModuleFileExtension;

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

@@ -1,3 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileExtensionForFormat = void 0;
+const getFileExtensionForFormat = (moduleFormat, featureFlags) => {
+    if (moduleFormat === "esm" /* ModuleFormat.ESM */ && featureFlags.zisi_pure_esm_mjs) {
+        return ".mjs" /* ModuleFileExtension.MJS */;
+    }
+    return ".js" /* ModuleFileExtension.JS */;
+};
+exports.getFileExtensionForFormat = getFileExtensionForFormat;
 //# sourceMappingURL=module_format.js.map

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

@@ -1,10 +1,12 @@
-import type { ModuleFormat } from './module_format.js';
+import type { FeatureFlags } from '../../../feature_flags.js';
+import { ModuleFormat } from './module_format.js';
 export declare type ArchiveFormat = 'none' | 'zip';
 interface ZipNodeParameters {
     aliases?: Map<string, string>;
     basePath: string;
     destFolder: string;
     extension: string;
+    featureFlags: FeatureFlags;
     filename: string;
     mainFile: string;
     moduleFormat: ModuleFormat;

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

@@ -14,26 +14,29 @@ const p_map_1 = __importDefault(require("p-map"));
 const archive_js_1 = require("../../../archive.js");
 const fs_js_1 = require("../../../utils/fs.js");
 const entry_file_js_1 = require("./entry_file.js");
+const module_format_js_1 = require("./module_format.js");
 const normalize_path_js_1 = require("./normalize_path.js");
 // 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, moduleFormat, rewrites = new Map(), srcFiles, }) {
-    const { contents: entryContents, filename: entryFilename } = (0, entry_file_js_1.getEntryFile)({
+const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites = new Map(), srcFiles, }) {
+    const entryFile = (0, entry_file_js_1.getEntryFile)({
         commonPrefix: basePath,
-        filename,
         mainFile,
         moduleFormat,
         userNamespace: DEFAULT_USER_SUBDIRECTORY,
     });
+    const entryFileExtension = (0, module_format_js_1.getFileExtensionForFormat)(moduleFormat, featureFlags);
+    const entryFilename = (0, path_1.basename)(filename, extension) + entryFileExtension;
     const functionFolder = (0, path_1.join)(destFolder, (0, path_1.basename)(filename, extension));
+    const entryFilePath = (0, path_1.resolve)(functionFolder, entryFilename);
     // Deleting the functions directory in case it exists before creating it.
     await (0, del_1.default)(functionFolder, { force: true });
     await fs_1.promises.mkdir(functionFolder, { recursive: true });
     // Writing entry file.
-    await fs_1.promises.writeFile((0, path_1.join)(functionFolder, entryFilename), entryContents);
+    await fs_1.promises.writeFile(entryFilePath, entryFile);
     // Copying source files.
     await (0, p_map_1.default)(srcFiles, (srcFile) => {
         const destPath = aliases.get(srcFile) || srcFile;
@@ -50,10 +53,11 @@ 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, moduleFormat, rewrites, srcFiles, }) {
+const createZipArchive = async function ({ aliases, basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
     const destPath = (0, path_1.join)(destFolder, `${(0, path_1.basename)(filename, extension)}.zip`);
     const { archive, output } = (0, archive_js_1.startZip)(destPath);
-    const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
+    const entryFileExtension = (0, module_format_js_1.getFileExtensionForFormat)(moduleFormat, featureFlags);
+    const entryFilename = (0, path_1.basename)(filename, extension) + entryFileExtension;
     const entryFilePath = (0, path_1.resolve)(basePath, entryFilename);
     // We don't need an entry file if it would end up with the same path as the
     // function's main file.
@@ -66,8 +70,8 @@ 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 = (0, entry_file_js_1.getEntryFile)({ commonPrefix: basePath, filename, mainFile, moduleFormat, userNamespace });
-        addEntryFileToZip(archive, entryFile);
+        const entryFile = (0, entry_file_js_1.getEntryFile)({ commonPrefix: basePath, mainFile, moduleFormat, userNamespace });
+        addEntryFileToZip(archive, entryFile, (0, path_1.basename)(entryFilePath));
     }
     const srcFilesInfos = await Promise.all(srcFiles.map(addStat));
     // We ensure this is not async, so that the archive's checksum is
@@ -93,7 +97,7 @@ const zipNodeJs = function ({ archiveFormat, ...options }) {
     return createDirectory(options);
 };
 exports.zipNodeJs = zipNodeJs;
-const addEntryFileToZip = function (archive, { contents, filename }) {
+const addEntryFileToZip = function (archive, contents, filename) {
     const contentBuffer = buffer_1.Buffer.from(contents);
     (0, archive_js_1.addZipContent)(archive, contentBuffer, filename);
 };

package/dist/utils/fs.d.ts

@@ -1,15 +1,16 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import { promises as fs } from 'fs';
 export declare type FsCache = Record<string, unknown>;
 export declare const cachedLstat: (cache: FsCache, path: string, opts?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
-export declare const cachedReaddir: (cache: FsCache, path: string, options: import("fs").ObjectEncodingOptions & {
+export declare const cachedReaddir: (cache: FsCache, path: string, options: {
+    encoding?: string | null | undefined;
     withFileTypes: true;
 }) => Promise<import("fs").Dirent[]>;
-export declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & import("events").Abortable & {
-    flag?: import("fs").OpenMode | undefined;
-}) | null | undefined) => Promise<string | Buffer>;
+export declare const cachedReadFile: (cache: FsCache, path: string, options?: string | {
+    encoding?: string | null | undefined;
+    flag?: string | number | undefined;
+} | null | undefined) => Promise<string | Buffer>;
 export declare const getPathWithExtension: (path: string, extension: string) => string;
 export declare const safeUnlink: (path: string) => Promise<void>;
 export declare const listFunctionsDirectories: (srcFolders: string[]) => Promise<string[]>;

package/dist/utils/remove_undefined.d.ts

@@ -1 +1,3 @@
-export declare const removeUndefined: <T>(obj: T) => T;
+export declare const removeUndefined: <T extends {
+    [key: string]: unknown;
+}>(obj: T) => T;

package/dist/zip.d.ts

@@ -14,9 +14,9 @@ declare type ZipFunctionsOptions = ZipFunctionOptions & {
     manifest?: string;
     parallelLimit?: number;
 };
-export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
+export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
     runtime: import("./main.js").RuntimeType;
     schedule?: string | undefined;
 })[]>;
-export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
+export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config, featureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
 export {};

package/dist/zip.js

@@ -30,13 +30,19 @@ const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFo
     const [paths] = await Promise.all([(0, fs_js_1.listFunctionsDirectories)(srcFolders), fs_1.promises.mkdir(destFolder, { recursive: true })]);
     const functions = await (0, index_js_1.getFunctionsFromPaths)(paths, { config, configFileDirectories, dedupe: true, featureFlags });
     const results = await (0, p_map_1.default)(functions.values(), async (func) => {
+        const functionFlags = {
+            ...featureFlags,
+            // If there's a `nodeModuleFormat` configuration property set to `esm`,
+            // extend the feature flags with `zisi_pure_esm_mjs` enabled.
+            ...(func.config.nodeModuleFormat === "esm" /* ModuleFormat.ESM */ ? { zisi_pure_esm_mjs: true } : {}),
+        };
         const zipResult = await func.runtime.zipFunction({
             archiveFormat,
             basePath,
             config: func.config,
             destFolder,
             extension: func.extension,
-            featureFlags,
+            featureFlags: functionFlags,
             filename: func.filename,
             mainFile: func.mainFile,
             name: func.name,
@@ -70,13 +76,19 @@ const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat
     }
     const { config, extension, filename, mainFile, name, runtime, srcDir, stat: stats, } = functions.values().next().value;
     await fs_1.promises.mkdir(destFolder, { recursive: true });
+    const functionFlags = {
+        ...featureFlags,
+        // If there's a `nodeModuleFormat` configuration property set to `esm`,
+        // extend the feature flags with `zisi_pure_esm_mjs` enabled.
+        ...(config.nodeModuleFormat === "esm" /* ModuleFormat.ESM */ ? { zisi_pure_esm_mjs: true } : {}),
+    };
     const zipResult = await runtime.zipFunction({
         archiveFormat,
         basePath,
         config,
         destFolder,
         extension,
-        featureFlags,
+        featureFlags: functionFlags,
         filename,
         mainFile,
         name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "6.0.0",
+  "version": "7.1.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -55,7 +55,7 @@
     "@babel/parser": "7.16.8",
     "@netlify/binary-info": "^1.0.0",
     "@netlify/esbuild": "0.14.25",
-    "@vercel/nft": "^0.21.0",
+    "@vercel/nft": "^0.22.0",
     "archiver": "^5.3.0",
     "common-path-prefix": "^3.0.0",
     "cp-file": "^9.0.0",
@@ -90,6 +90,7 @@
     "@netlify/eslint-config-node": "^7.0.0",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
+    "@types/node": "^12.20.55",
     "@types/normalize-path": "^3.0.0",
     "@types/resolve": "^1.20.1",
     "@types/semver": "^7.3.8",