@netlify/zip-it-and-ship-it 6.0.1-beta → 7.0.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.
@@ -129,7 +128,7 @@ The following properties are accepted:
 - `nodeVersion`
 
   - _Type_: `string`\
-  - _Default value_: `12.x`
+  - _Default value_: `16.x`
 
   The version of Node.js to use as the compilation target. Possible values:
 
@@ -137,6 +136,7 @@ The following properties are accepted:
   - `10.x` (or `nodejs10.x`)
   - `12.x` (or `nodejs12.x`)
   - `14.x` (or `nodejs14.x`)
+  - `16.x` (or `nodejs16.x`)
 
 - `rustTargetDirectory`
 
@@ -441,9 +441,9 @@ need to be the same as the one used when installing those native modules.
 
 In Netlify, this is done by ensuring that the following Node.js versions are the same:
 
-- Build-time Node.js version: this defaults to Node `12`, but can be
+- Build-time Node.js version: this defaults to Node `16`, but can be
   [overridden with a `.nvmrc` or `NODE_VERSION` environment variable](https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript).
-- Function runtime Node.js version: this defaults to `nodejs12.x` but can be
+- Function runtime Node.js version: this defaults to `nodejs16.x` but can be
   [overridden with a `AWS_LAMBDA_JS_RUNTIME` environment variable](https://docs.netlify.com/functions/build-with-javascript/#runtime-settings).
 
 Note that this problem might not apply for Node.js native modules using the [N-API](https://nodejs.org/api/n-api.html).

package/dist/bin.d.ts

@@ -1,2 +1,5 @@
 #!/usr/bin/env node
+declare global {
+    var ZISI_CLI: boolean;
+}
 export {};

package/dist/bin.js

@@ -14,6 +14,7 @@ const runCli = async function () {
     // back from `parseArgs()`.
     const { destFolder, srcFolder, ...options } = parseArgs();
     try {
+        global.ZISI_CLI = true;
         // @ts-expect-error TODO: `options` is not getting the right types.
         const zipped = await (0, main_js_1.zipFunctions)(srcFolder, destFolder, options);
         console.log(JSON.stringify(zipped, null, 2));

package/dist/config.d.ts

@@ -1,12 +1,13 @@
+import type { FeatureFlags } from './feature_flags.js';
 import { FunctionSource } from './function.js';
-import type { NodeBundlerName } from './runtimes/node/bundlers/index.js';
+import type { NodeBundlerType } from './runtimes/node/bundlers/types.js';
 import type { NodeVersionString } from './runtimes/node/index.js';
-export interface FunctionConfig {
+interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
     includedFilesBasePath?: string;
     ignoredNodeModules?: string[];
-    nodeBundler?: NodeBundlerName;
+    nodeBundler?: NodeBundlerType;
     nodeSourcemap?: boolean;
     nodeVersion?: NodeVersionString;
     processDynamicNodeImports?: boolean;
@@ -15,9 +16,12 @@ export interface FunctionConfig {
     zipGo?: boolean;
 }
 declare type GlobPattern = string;
-export declare type Config = Record<GlobPattern, FunctionConfig>;
-export declare const getConfigForFunction: ({ config, func, }: {
+declare type Config = Record<GlobPattern, FunctionConfig>;
+declare type FunctionWithoutConfig = Omit<FunctionSource, 'config'>;
+declare const getConfigForFunction: ({ config, configFileDirectories, func, featureFlags, }: {
     config?: Config | undefined;
-    func: Omit<FunctionSource, 'config'>;
-}) => FunctionConfig;
-export {};
+    configFileDirectories?: string[] | undefined;
+    func: FunctionWithoutConfig;
+    featureFlags: FeatureFlags;
+}) => Promise<FunctionConfig>;
+export { Config, FunctionConfig, FunctionWithoutConfig, getConfigForFunction };

package/dist/config.js

@@ -4,9 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfigForFunction = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const is_path_inside_1 = __importDefault(require("is-path-inside"));
 const merge_options_1 = __importDefault(require("merge-options"));
 const matching_js_1 = require("./utils/matching.js");
-const getConfigForFunction = ({ config, func, }) => {
+const getConfigForFunction = async ({ config, configFileDirectories, func, featureFlags, }) => {
+    const fromConfig = getFromMainConfig({ config, func });
+    // We try to read from a function config file if the function directory is
+    // inside one of `configFileDirectories`.
+    const shouldReadConfigFile = featureFlags.project_deploy_configuration_api_use_per_function_configuration_files &&
+        (configFileDirectories === null || configFileDirectories === void 0 ? void 0 : configFileDirectories.some((directory) => (0, is_path_inside_1.default)(func.mainFile, directory)));
+    if (!shouldReadConfigFile) {
+        return fromConfig;
+    }
+    const fromFile = await getFromFile(func);
+    return {
+        ...fromConfig,
+        ...fromFile,
+    };
+};
+exports.getConfigForFunction = getConfigForFunction;
+const getFromMainConfig = ({ config, func, }) => {
     if (!config) {
         return {};
     }
@@ -29,5 +48,19 @@ const getConfigForFunction = ({ config, func, }) => {
         .map(({ expression }) => config[expression]);
     return merge_options_1.default.apply({ concatArrays: true, ignoreUndefined: true }, matches);
 };
-exports.getConfigForFunction = getConfigForFunction;
+const getFromFile = async (func) => {
+    const filename = `${(0, path_1.basename)(func.mainFile, (0, path_1.extname)(func.mainFile))}.json`;
+    const configFilePath = (0, path_1.join)((0, path_1.dirname)(func.mainFile), filename);
+    try {
+        const data = await fs_1.promises.readFile(configFilePath, 'utf8');
+        const configFile = JSON.parse(data);
+        if (configFile.version === 1) {
+            return configFile.config;
+        }
+    }
+    catch {
+        // no-op
+    }
+    return {};
+};
 //# sourceMappingURL=config.js.map

package/dist/feature_flags.js

@@ -3,11 +3,20 @@ 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,
-    zisi_functions_api_v2: 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.
 const getFlags = (input = {}, flags = exports.defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/main.d.ts

@@ -1,11 +1,14 @@
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
-import { RuntimeName } from './runtimes/runtime.js';
+import { RuntimeType } from './runtimes/runtime.js';
 export { zipFunction, zipFunctions } from './zip.js';
+export { NodeBundlerType } from './runtimes/node/bundlers/types.js';
+export { RuntimeType } from './runtimes/runtime.js';
+export { ModuleFormat } from './runtimes/node/utils/module_format.js';
 interface ListedFunction {
     name: string;
     mainFile: string;
-    runtime: RuntimeName;
+    runtime: RuntimeType;
     extension: string;
     schedule?: string;
 }
@@ -18,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/main.js

@@ -11,10 +11,10 @@ Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function
 Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_js_1.zipFunctions; } });
 const augmentWithISC = async (func) => {
     // ISC is currently only supported in JavaScript and TypeScript functions.
-    if (func.runtime.name !== 'js') {
+    if (func.runtime.name !== "js" /* RuntimeType.JAVASCRIPT */) {
         return func;
     }
-    const inSourceConfig = await (0, index_js_2.findISCDeclarationsInPath)(func.mainFile);
+    const inSourceConfig = await (0, index_js_2.findISCDeclarationsInPath)(func.mainFile, func.name);
     return { ...func, inSourceConfig };
 };
 // List all Netlify Functions main entry files for a specific directory

package/dist/runtimes/detect_runtime.d.ts

@@ -1,6 +1,6 @@
 import { FsCache } from '../utils/fs.js';
-import type { RuntimeName } from './runtime.js';
+import { RuntimeType } from './runtime.js';
 export declare const detectBinaryRuntime: ({ fsCache, path, }: {
     fsCache: FsCache;
     path: string;
-}) => Promise<RuntimeName | undefined>;
+}) => Promise<RuntimeType | undefined>;

package/dist/runtimes/detect_runtime.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectBinaryRuntime = void 0;
-const elf_cam_1 = require("elf-cam");
+const binary_info_1 = require("@netlify/binary-info");
 const fs_js_1 = require("../utils/fs.js");
+const isValidFunctionBinary = (info) => info.arch === binary_info_1.Arch.Amd64 && info.platform === binary_info_1.Platform.Linux;
+const warnIncompatibleBinary = function (path, binaryInfo) {
+    if (!global.ZISI_CLI) {
+        console.warn(`
+Found incompatible prebuilt function binary in ${path}.
+The binary needs to be built for Linux/Amd64, but it was built for ${binary_info_1.Platform[binaryInfo.platform]}/${binary_info_1.Arch[binaryInfo.arch]}`);
+    }
+    return undefined;
+};
 // Try to guess the runtime by inspecting the binary file.
 const detectBinaryRuntime = async function ({ fsCache, path, }) {
     try {
@@ -10,17 +19,22 @@ const detectBinaryRuntime = async function ({ fsCache, path, }) {
         // We're using the Type Assertion because the `cachedReadFile` abstraction
         // loses part of the return type information. We can safely say it's a
         // Buffer in this case because we're not specifying an encoding.
-        const binaryType = (0, elf_cam_1.detect)(buffer);
-        switch (binaryType) {
-            case elf_cam_1.Runtime.Go:
-                return 'go';
-            case elf_cam_1.Runtime.Rust:
-                return 'rs';
+        const binaryInfo = (0, binary_info_1.detect)(buffer);
+        if (!isValidFunctionBinary(binaryInfo)) {
+            return warnIncompatibleBinary(path, binaryInfo);
+        }
+        switch (binaryInfo.runtime) {
+            case binary_info_1.Runtime.Go:
+                return "go" /* RuntimeType.GO */;
+            case binary_info_1.Runtime.Rust:
+                return "rs" /* RuntimeType.RUST */;
             default:
                 return undefined;
         }
     }
-    catch { }
+    catch {
+        // Possible errors are: non binary files, arch/platforms not supported by binary-info, path is directory
+    }
 };
 exports.detectBinaryRuntime = detectBinaryRuntime;
 //# sourceMappingURL=detect_runtime.js.map

package/dist/runtimes/go/builder.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const error_js_1 = require("../../utils/error.js");
 const shell_js_1 = require("../../utils/shell.js");
 const build = async ({ destPath, mainFile, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
@@ -17,10 +18,8 @@ const build = async ({ destPath, mainFile, srcDir }) => {
         });
     }
     catch (error) {
-        const runtime = 'go';
-        error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime } };
         console.error(`Could not compile Go function ${functionName}:\n`);
-        throw error;
+        throw error_js_1.FunctionBundlingUserError.addCustomErrorInfo(error, { functionName, runtime: "go" /* RuntimeType.GO */ });
     }
     const stat = await fs_1.promises.lstat(destPath);
     return {

package/dist/runtimes/go/index.js

@@ -31,7 +31,7 @@ const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
 };
 const findFunctionInPath = async function ({ fsCache, path }) {
     const runtime = await (0, detect_runtime_js_1.detectBinaryRuntime)({ fsCache, path });
-    if (runtime === 'go') {
+    if (runtime === "go" /* RuntimeType.GO */) {
         return processBinary({ fsCache, path });
     }
     const goSourceFile = await detectGoFunction({ fsCache, path });
@@ -109,6 +109,6 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
     }
     return { config, path: destPath };
 };
-const runtime = { findFunctionsInPaths, findFunctionInPath, name: 'go', zipFunction };
+const runtime = { findFunctionsInPaths, findFunctionInPath, name: "go" /* RuntimeType.GO */, zipFunction };
 exports.default = runtime;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/index.d.ts

@@ -5,8 +5,9 @@ declare type FunctionMap = Map<string, FunctionSource>;
 /**
  * Gets a list of functions found in a list of paths.
  */
-export declare const getFunctionsFromPaths: (paths: string[], { config, dedupe, featureFlags, }?: {
+export declare const getFunctionsFromPaths: (paths: string[], { config, configFileDirectories, dedupe, featureFlags, }?: {
     config?: Config | undefined;
+    configFileDirectories?: string[] | undefined;
     dedupe?: boolean | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionMap>;

package/dist/runtimes/index.js

@@ -47,7 +47,7 @@ const RUNTIMES = [index_js_2.default, index_js_1.default, index_js_3.default];
 /**
  * Gets a list of functions found in a list of paths.
  */
-const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFlags = feature_flags_js_1.defaultFlags, } = {}) => {
+const getFunctionsFromPaths = async (paths, { config, configFileDirectories = [], dedupe = false, featureFlags = feature_flags_js_1.defaultFlags, } = {}) => {
     const fsCache = makeFsCache();
     // We cycle through the ordered array of runtimes, passing each one of them
     // through `findFunctionsInRuntime`. For each iteration, we collect all the
@@ -67,9 +67,10 @@ const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFla
             remainingPaths: runtimePaths,
         };
     }, Promise.resolve({ functions: [], remainingPaths: paths }));
-    const functionsWithConfig = functions.map(([name, func]) => [
+    const functionConfigs = await Promise.all(functions.map(([, func]) => (0, config_js_1.getConfigForFunction)({ config, configFileDirectories, func, featureFlags })));
+    const functionsWithConfig = functions.map(([name, func], index) => [
         name,
-        { ...func, config: (0, config_js_1.getConfigForFunction)({ config, func }) },
+        { ...func, config: functionConfigs[index] },
     ]);
     return new Map(functionsWithConfig);
 };
@@ -82,10 +83,11 @@ const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_
     for (const runtime of RUNTIMES) {
         const func = await runtime.findFunctionInPath({ path, fsCache, featureFlags });
         if (func) {
+            const functionConfig = await (0, config_js_1.getConfigForFunction)({ config, func: { ...func, runtime }, featureFlags });
             return {
                 ...func,
                 runtime,
-                config: (0, config_js_1.getConfigForFunction)({ config, func: { ...func, runtime } }),
+                config: functionConfig,
             };
         }
     }

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

@@ -4,7 +4,9 @@ exports.bundleJsFile = exports.ESBUILD_LOG_LIMIT = void 0;
 const path_1 = require("path");
 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");
@@ -15,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)();
@@ -55,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,
@@ -66,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,
@@ -76,6 +83,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
         });
         const bundlePaths = getBundlePaths({
             destFolder: targetDirectory,
+            extension,
             outputs: metafile.outputs,
             srcFile,
         });
@@ -86,6 +94,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
             additionalPaths,
             bundlePaths,
             cleanTempFiles,
+            extension,
             inputs,
             moduleFormat,
             nativeNodeModules,
@@ -94,13 +103,11 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
         };
     }
     catch (error) {
-        const bundler = 'esbuild';
-        const runtime = 'js';
-        error.customErrorInfo = {
-            type: 'functionsBundling',
-            location: { bundler, functionName: name, runtime },
-        };
-        throw error;
+        throw error_js_1.FunctionBundlingUserError.addCustomErrorInfo(error, {
+            functionName: name,
+            runtime: "js" /* RuntimeType.JAVASCRIPT */,
+            bundler: "esbuild" /* NodeBundlerType.ESBUILD */,
+        });
     }
 };
 exports.bundleJsFile = bundleJsFile;
@@ -108,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
@@ -122,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

@@ -1,15 +1,16 @@
 import { FeatureFlags } from '../../../../feature_flags';
 import { ModuleFormat } from '../../utils/module_format';
+import { NodeVersionString } from '../../utils/node_version';
 declare const versionMap: {
     readonly '8.x': "node8";
     readonly '10.x': "node10";
     readonly '12.x': "node12";
     readonly '14.x': "node14";
+    readonly '16.x': "node16";
 };
-declare type VersionKeys = keyof typeof versionMap;
-declare type VersionValues = typeof versionMap[VersionKeys];
-declare const getBundlerTarget: (suppliedVersion?: string) => VersionValues;
-declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, configVersion?: string) => Promise<{
+declare type VersionValues = typeof versionMap[keyof typeof versionMap];
+declare const getBundlerTarget: (suppliedVersion?: NodeVersionString) => VersionValues;
+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

@@ -8,6 +8,7 @@ const versionMap = {
     '10.x': 'node10',
     '12.x': 'node12',
     '14.x': 'node14',
+    '16.x': 'node16',
 };
 const getBundlerTarget = (suppliedVersion) => {
     const version = normalizeVersion(suppliedVersion);
@@ -17,18 +18,24 @@ 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) {
         return {
             includedFiles: [packageJsonFile.path],
-            moduleFormat: 'esm',
+            moduleFormat: "esm" /* ModuleFormat.ESM */,
         };
     }
     return {
         includedFiles: [],
-        moduleFormat: 'cjs',
+        moduleFormat: "cjs" /* ModuleFormat.COMMONJS */,
     };
 };
 exports.getModuleFormat = getModuleFormat;

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

@@ -1,6 +1,6 @@
-import type { BundleFunction } from '../index.js';
+import type { BundleFunction } from '../types.js';
 declare const bundler: {
     bundle: BundleFunction;
-    getSrcFiles: import("../index.js").GetSrcFilesFunction;
+    getSrcFiles: import("../types.js").GetSrcFilesFunction;
 };
 export default bundler;

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/esbuild/plugin_dynamic_imports.js

@@ -20,7 +20,6 @@ const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, process
     name: 'dynamic-imports',
     setup(build) {
         const cache = new Map();
-        // eslint-disable-next-line complexity
         build.onDynamicImport({ filter: /.*/ }, async (args) => {
             const { expression, resolveDir } = args;
             // Don't attempt to parse the expression if the base path isn't defined,

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

@@ -1,3 +1,3 @@
 import type { Plugin } from '@netlify/esbuild';
-import type { NativeNodeModules } from '../index.js';
+import type { NativeNodeModules } from '../types.js';
 export declare const getNativeModulesPlugin: (externalizedModules: NativeNodeModules) => Plugin;

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

@@ -22,7 +22,7 @@ const getNativeModulesPlugin = (externalizedModules) => ({
     name: 'external-native-modules',
     setup(build) {
         const cache = {};
-        // eslint-disable-next-line complexity, max-statements
+        // eslint-disable-next-line max-statements
         build.onResolve({ filter: packageFilter }, async (args) => {
             const pkg = packageName.exec(args.path);
             if (!pkg)

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

@@ -1,2 +1,2 @@
-import type { GetSrcFilesFunction } from '../index.js';
+import type { GetSrcFilesFunction } from '../types.js';
 export declare const getSrcFiles: GetSrcFilesFunction;