@netlify/zip-it-and-ship-it 5.6.0 → 5.7.3

package/README.md

@@ -32,15 +32,11 @@ npm install @netlify/zip-it-and-ship-it
 - _Return value_: `Promise<object[]>`
 
 ```js
-const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
+import { zipFunctions } from '@netlify/zip-it-and-ship-it'
 
-const zipNetlifyFunctions = async function () {
-  const archives = await zipFunctions('functions', 'functions-dist', {
-    archiveFormat: 'zip',
-  })
-
-  return archives
-}
+const archives = await zipFunctions('functions', 'functions-dist', {
+  archiveFormat: 'zip',
+})
 ```
 
 Creates Zip `archives` from Node.js, Go, and Rust programs. Those `archives` are ready to be uploaded to AWS Lambda.
@@ -258,13 +254,9 @@ Additionally, the following properties also exist for Node.js functions:
 - _Return value_: `object | undefined`
 
 ```js
-const { zipFunction } = require('@netlify/zip-it-and-ship-it')
-
-const zipNetlifyFunctions = async function () {
-  const archive = await zipFunctions('functions/function.js', 'functions-dist')
+import { zipFunction } from '@netlify/zip-it-and-ship-it'
 
-  return archive
-}
+const archive = await zipFunctions('functions/function.js', 'functions-dist')
 ```
 
 This is like [`zipFunctions()`](#zipfunctionssrcfolder-destfolder-options) except it bundles a single Function.
@@ -276,13 +268,9 @@ The return value is `undefined` if the function is invalid.
 Returns the list of functions to bundle.
 
 ```js
-const { listFunctions } = require('@netlify/zip-it-and-ship-it')
-
-const listNetlifyFunctions = async function () {
-  const functions = await listFunctions('functions/function.js')
+import { listFunctions } from '@netlify/zip-it-and-ship-it'
 
-  return functions
-}
+const functions = await listFunctions('functions/function.js')
 ```
 
 ### `srcFolders`
@@ -326,12 +314,9 @@ Like [`listFunctions()`](#listfunctionssrcfolder), except it returns not only th
 their required files. This is much slower.
 
 ```js
-const { listFunctionsFiles } = require('@netlify/zip-it-and-ship-it')
+import { listFunctionsFiles } from '@netlify/zip-it-and-ship-it'
 
-const listNetlifyFunctionsFiles = async function () {
-  const functions = await listFunctionsFiles('functions/function.js')
-  return functions
-}
+const functions = await listFunctionsFiles('functions/function.js')
 ```
 
 ### `srcFolders`
@@ -400,20 +385,16 @@ included in the bundle.
 You can enable esbuild by setting the [`config` option](#config) when calling `zipFunction` or `zipFunctions`:
 
 ```js
-const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
-
-const zipNetlifyFunctions = async function () {
-  const archives = await zipFunctions('functions', 'functions-dist', {
-    config: {
-      // Applying these settings to all functions.
-      '*': {
-        nodeBundler: 'esbuild',
-      },
-    },
-  })
+import { zipFunctions } from '@netlify/zip-it-and-ship-it'
 
-  return archives
-}
+const archives = await zipFunctions('functions', 'functions-dist', {
+  config: {
+    // Applying these settings to all functions.
+    '*': {
+      nodeBundler: 'esbuild',
+    },
+  },
+})
 ```
 
 # Feature flags

package/dist/archive.d.ts

@@ -2,14 +2,12 @@ import { Buffer } from 'buffer';
 import { Stats } from 'fs';
 import { Writable } from 'stream';
 import { Archiver } from 'archiver';
-declare type ArchiveFormat = 'none' | 'zip';
-declare const startZip: (destPath: string) => {
+export { Archiver as ZipArchive } from 'archiver';
+export declare type ArchiveFormat = 'none' | 'zip';
+export declare const startZip: (destPath: string) => {
     archive: Archiver;
     output: Writable;
 };
-declare const addZipFile: (archive: Archiver, file: string, name: string, stat: Stats) => void;
-declare const addZipContent: (archive: Archiver, content: Buffer | string, name: string) => void;
-declare const endZip: (archive: Archiver, output: Writable) => Promise<void>;
-export { startZip, addZipFile, addZipContent, endZip };
-export type { ArchiveFormat };
-export { Archiver as ZipArchive } from 'archiver';
+export declare const addZipFile: (archive: Archiver, file: string, name: string, stat: Stats) => void;
+export declare const addZipContent: (archive: Archiver, content: Buffer | string, name: string) => void;
+export declare const endZip: (archive: Archiver, output: Writable) => Promise<void>;

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,23 +1,23 @@
 import { FunctionSource } from './function';
-import type { NodeBundlerName, NodeVersion } from './runtimes/node';
-interface FunctionConfig {
+import type { NodeVersionString } from './runtimes/node';
+import type { NodeBundlerName } from './runtimes/node/bundlers';
+export interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
     includedFilesBasePath?: string;
     ignoredNodeModules?: string[];
     nodeBundler?: NodeBundlerName;
     nodeSourcemap?: boolean;
-    nodeVersion?: NodeVersion;
+    nodeVersion?: NodeVersionString;
     processDynamicNodeImports?: boolean;
     rustTargetDirectory?: string;
     schedule?: string;
     zipGo?: boolean;
 }
 declare type GlobPattern = string;
-declare type Config = Record<GlobPattern, FunctionConfig>;
-declare const getConfigForFunction: ({ config, func, }: {
+export declare type Config = Record<GlobPattern, FunctionConfig>;
+export declare const getConfigForFunction: ({ config, func, }: {
     config?: Config | undefined;
     func: Omit<FunctionSource, 'config'>;
 }) => FunctionConfig;
-export { getConfigForFunction };
-export type { Config, FunctionConfig };
+export {};

package/dist/feature_flags.d.ts

@@ -1,6 +1,4 @@
-declare const FLAGS: Record<string, boolean>;
-declare type FeatureFlag = keyof typeof FLAGS;
-declare type FeatureFlags = Record<FeatureFlag, boolean>;
-declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => {};
-export { FLAGS as defaultFlags, getFlags };
-export type { FeatureFlag, FeatureFlags };
+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>) => {};

package/dist/feature_flags.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFlags = exports.defaultFlags = void 0;
 const process_1 = require("process");
-const FLAGS = {
+exports.defaultFlags = {
     buildGoSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
     buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
     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.
-const getFlags = (input = {}, flags = FLAGS) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
+const getFlags = (input = {}, flags = exports.defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,
     [key]: input[key] === undefined ? defaultValue : input[key],
 }), {});

package/dist/function.d.ts

@@ -2,13 +2,13 @@
 import { Stats } from 'fs';
 import type { FunctionConfig } from './config';
 import type { Runtime, ZipFunctionResult } from './runtimes/runtime';
-declare type FunctionArchive = ZipFunctionResult & {
+export declare type FunctionArchive = ZipFunctionResult & {
     mainFile: string;
     name: string;
     runtime: Runtime;
     size?: number;
 };
-interface SourceFile {
+export interface SourceFile {
     extension: string;
     filename: string;
     mainFile: string;
@@ -17,8 +17,7 @@ interface SourceFile {
     srcPath: string;
     stat: Stats;
 }
-declare type FunctionSource = SourceFile & {
+export declare type FunctionSource = SourceFile & {
     config: FunctionConfig;
     runtime: Runtime;
 };
-export { FunctionArchive, FunctionSource, SourceFile };

package/dist/main.d.ts

@@ -1,6 +1,7 @@
 import { Config } from './config';
 import { FeatureFlags } from './feature_flags';
 import { RuntimeName } from './runtimes/runtime';
+export { zipFunction, zipFunctions } from './zip';
 interface ListedFunction {
     name: string;
     mainFile: string;
@@ -17,16 +18,14 @@ interface ListFunctionsOptions {
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
-declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction | undefined>;
-declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
-export { listFunctions, listFunction, listFunctionsFiles };
-export { zipFunction, zipFunctions } from './zip';
+export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;

package/dist/main.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = void 0;
+exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = exports.zipFunctions = exports.zipFunction = void 0;
 const path_1 = require("path");
 const feature_flags_1 = require("./feature_flags");
 const runtimes_1 = require("./runtimes");
 const in_source_config_1 = require("./runtimes/node/in_source_config");
 const fs_1 = require("./utils/fs");
+var zip_1 = require("./zip");
+Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_1.zipFunction; } });
+Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_1.zipFunctions; } });
 const augmentWithISC = async (func) => {
     // ISC is currently only supported in JavaScript and TypeScript functions.
     if (func.runtime.name !== 'js') {
@@ -68,7 +71,4 @@ const getSrcFiles = async function ({ extension, runtime, srcPath, ...args }) {
         ...args,
     });
 };
-var zip_1 = require("./zip");
-Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_1.zipFunction; } });
-Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_1.zipFunctions; } });
 //# sourceMappingURL=main.js.map

package/dist/manifest.d.ts

@@ -6,7 +6,7 @@ interface ManifestFunction {
     runtime: string;
     schedule?: string;
 }
-interface Manifest {
+export interface Manifest {
     functions: ManifestFunction[];
     system: {
         arch: string;
@@ -15,9 +15,8 @@ interface Manifest {
     timestamp: number;
     version: number;
 }
-declare const createManifest: ({ functions, path }: {
+export declare const createManifest: ({ functions, path }: {
     functions: FunctionResult[];
     path: string;
 }) => Promise<void>;
-export { createManifest };
-export type { Manifest };
+export {};

package/dist/runtimes/detect_runtime.d.ts

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

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-declare const build: ({ destPath, mainFile, srcDir }: {
+export declare const build: ({ destPath, mainFile, srcDir }: {
     destPath: string;
     mainFile: string;
     srcDir: string;
@@ -10,4 +10,3 @@ declare const build: ({ destPath, mainFile, srcDir }: {
     srcPath: string;
     stat: import("fs").Stats;
 }>;
-export { build };

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/index.d.ts

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

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

@@ -1,6 +1,6 @@
 import type { FunctionConfig } from '../../../../config';
-declare const ESBUILD_LOG_LIMIT = 10;
-declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, ignoredModules, name, srcDir, srcFile, }: {
+export declare const ESBUILD_LOG_LIMIT = 10;
+export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, ignoredModules, name, srcDir, srcFile, }: {
     additionalModulePaths?: string[] | undefined;
     basePath?: string | undefined;
     config: FunctionConfig;
@@ -18,4 +18,3 @@ declare const bundleJsFile: ({ additionalModulePaths, basePath, config, external
     nodeModulesWithDynamicImports: string[];
     warnings: import("@netlify/esbuild").Message[];
 }>;
-export { bundleJsFile, ESBUILD_LOG_LIMIT };

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ESBUILD_LOG_LIMIT = exports.bundleJsFile = void 0;
+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");
@@ -12,8 +12,7 @@ const plugin_node_builtin_1 = require("./plugin_node_builtin");
 // Maximum number of log messages that an esbuild instance will produce. This
 // limit is important to avoid out-of-memory errors due to too much data being
 // sent in the Go<>Node IPC channel.
-const ESBUILD_LOG_LIMIT = 10;
-exports.ESBUILD_LOG_LIMIT = ESBUILD_LOG_LIMIT;
+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'];
@@ -59,7 +58,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
             entryPoints: [srcFile],
             external,
             logLevel: 'warning',
-            logLimit: ESBUILD_LOG_LIMIT,
+            logLimit: exports.ESBUILD_LOG_LIMIT,
             metafile: true,
             nodePaths: additionalModulePaths,
             outdir: targetDirectory,

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

@@ -6,5 +6,5 @@ declare const versionMap: {
 };
 declare type VersionKeys = keyof typeof versionMap;
 declare type VersionValues = typeof versionMap[VersionKeys];
-declare const getBundlerTarget: (suppliedVersion?: string | undefined) => VersionValues;
-export { getBundlerTarget };
+export declare const getBundlerTarget: (suppliedVersion?: string | undefined) => VersionValues;
+export {};

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/plugin_dynamic_imports.d.ts

@@ -1,9 +1,8 @@
 import type { Plugin } from '@netlify/esbuild';
-declare const getDynamicImportsPlugin: ({ basePath, includedPaths, moduleNames, processImports, srcDir, }: {
+export declare const getDynamicImportsPlugin: ({ basePath, includedPaths, moduleNames, processImports, srcDir, }: {
     basePath?: string | undefined;
     includedPaths: Set<string>;
     moduleNames: Set<string>;
     processImports: boolean;
     srcDir: string;
 }) => Plugin;
-export { getDynamicImportsPlugin };

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

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

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

@@ -1,3 +1,2 @@
 import type { Plugin } from '@netlify/esbuild';
-declare const getNodeBuiltinPlugin: () => Plugin;
-export { getNodeBuiltinPlugin };
+export declare const getNodeBuiltinPlugin: () => Plugin;

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

@@ -1,7 +1,6 @@
-declare const getExternalAndIgnoredModulesFromSpecialCases: ({ srcDir }: {
+export declare const getExternalAndIgnoredModulesFromSpecialCases: ({ srcDir }: {
     srcDir: string;
 }) => Promise<{
     externalModules: string[];
     ignoredModules: string[];
 }>;
-export { getExternalAndIgnoredModulesFromSpecialCases };

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/esbuild/src_files.d.ts

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

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

@@ -1,12 +1,13 @@
 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>>;
-declare type BundleFunction = (args: {
+export declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
+export declare type BundleFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: Record<FeatureFlag, boolean>;
@@ -20,11 +21,12 @@ declare type BundleFunction = (args: {
     cleanupFunction?: CleanupFunction;
     inputs: string[];
     mainFile: string;
+    moduleFormat: ModuleFormat;
     nativeNodeModules?: NativeNodeModules;
     nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
 }>;
-declare type GetSrcFilesFunction = (args: {
+export declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: FeatureFlags;
@@ -35,6 +37,10 @@ interface NodeBundler {
     bundle: BundleFunction;
     getSrcFiles: GetSrcFilesFunction;
 }
-declare const getBundler: (name: NodeBundlerName) => NodeBundler;
-export { getBundler };
-export type { BundleFunction, GetSrcFilesFunction, NativeNodeModules };
+export declare const getBundler: (name: NodeBundlerName) => NodeBundler;
+export declare const getDefaultBundler: ({ extension, mainFile, featureFlags, }: {
+    extension: string;
+    mainFile: string;
+    featureFlags: FeatureFlags;
+}) => Promise<NodeBundlerName>;
+export {};

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,17 @@
 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';
+export 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;
+}>;