@netlify/zip-it-and-ship-it 9.20.0 → 9.22.0

package/dist/main.d.ts

@@ -1,5 +1,6 @@
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
+import { ModuleFormat } from './runtimes/node/utils/module_format.js';
 import { RuntimeName } from './runtimes/runtime.js';
 export { Config, FunctionConfig } from './config.js';
 export { zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
@@ -16,6 +17,7 @@ export interface ListedFunction {
     schedule?: string;
     displayName?: string;
     generator?: string;
+    inputModuleFormat?: ModuleFormat;
 }
 type ListedFunctionFile = ListedFunction & {
     srcFile: string;
@@ -27,16 +29,20 @@ interface ListFunctionsOptions {
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC, }?: {
-    featureFlags?: Partial<Record<"buildRustSource" | "parseWithEsbuild" | "traceWithNft" | "zisi_pure_esm" | "zisi_pure_esm_mjs" | "zisi_output_cjs_extension" | "zisi_unique_entry_file" | "zisi_esbuild_fail_double_glob" | "zisi_golang_use_al2", boolean>> | undefined;
-    config?: Config | undefined;
-    configFileDirectories?: string[] | undefined;
-    parseISC?: boolean | undefined;
-}) => Promise<ListedFunction[]>;
-export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC, }?: {
-    featureFlags?: Partial<Record<"buildRustSource" | "parseWithEsbuild" | "traceWithNft" | "zisi_pure_esm" | "zisi_pure_esm_mjs" | "zisi_output_cjs_extension" | "zisi_unique_entry_file" | "zisi_esbuild_fail_double_glob" | "zisi_golang_use_al2", boolean>> | undefined;
-    config?: Config | undefined;
-    configFileDirectories?: string[] | undefined;
-    parseISC?: boolean | undefined;
-}) => Promise<ListedFunction | undefined>;
+interface ListFunctionsOptions {
+    basePath?: string;
+    config?: Config;
+    configFileDirectories?: string[];
+    featureFlags?: FeatureFlags;
+    parseISC?: boolean;
+}
+export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC }?: ListFunctionsOptions) => Promise<ListedFunction[]>;
+interface ListFunctionOptions {
+    basePath?: string;
+    config?: Config;
+    configFileDirectories?: string[];
+    featureFlags?: FeatureFlags;
+    parseISC?: boolean;
+}
+export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC }?: ListFunctionOptions) => Promise<ListedFunction | undefined>;
 export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, parseISC, }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;

package/dist/main.js

@@ -1,7 +1,7 @@
 import { extname } from 'path';
 import { getFlags } from './feature_flags.js';
 import { getFunctionFromPath, getFunctionsFromPaths } from './runtimes/index.js';
-import { findISCDeclarationsInPath } from './runtimes/node/in_source_config/index.js';
+import { parseFile } from './runtimes/node/in_source_config/index.js';
 import { RUNTIME } from './runtimes/runtime.js';
 import { RuntimeCache } from './utils/cache.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
@@ -11,38 +11,38 @@ export { ARCHIVE_FORMAT } from './archive.js';
 export { NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 export { RUNTIME } from './runtimes/runtime.js';
 export { MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
-const augmentWithISC = async (func) => {
-    // ISC is currently only supported in JavaScript and TypeScript functions
-    // and only supports scheduled functions.
+const augmentWithStaticAnalysis = async (func) => {
     if (func.runtime.name !== RUNTIME.JAVASCRIPT) {
         return func;
     }
-    const inSourceConfig = await findISCDeclarationsInPath(func.mainFile, {
+    const staticAnalysisResult = await parseFile(func.mainFile, {
         functionName: func.name,
         logger: getLogger(),
     });
-    return { ...func, inSourceConfig };
+    return { ...func, staticAnalysisResult };
 };
 // List all Netlify Functions main entry files for a specific directory
-export const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false, } = {}) {
+export const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
     const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
     const paths = await listFunctionsDirectories(srcFolders);
     const cache = new RuntimeCache();
     const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
     const functions = [...functionsMap.values()];
-    const augmentedFunctions = parseISC ? await Promise.all(functions.map((func) => augmentWithISC(func))) : functions;
+    const augmentedFunctions = parseISC
+        ? await Promise.all(functions.map((func) => augmentWithStaticAnalysis(func)))
+        : functions;
     return augmentedFunctions.map(getListedFunction);
 };
 // Finds a function at a specific path.
-export const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false, } = {}) {
+export const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
     const cache = new RuntimeCache();
     const func = await getFunctionFromPath(path, { cache, config, configFileDirectories, featureFlags });
     if (!func) {
         return;
     }
-    const augmentedFunction = parseISC ? await augmentWithISC(func) : func;
+    const augmentedFunction = parseISC ? await augmentWithStaticAnalysis(func) : func;
     return getListedFunction(augmentedFunction);
 };
 // List all Netlify Functions files for a specific directory
@@ -53,11 +53,13 @@ export const listFunctionsFiles = async function (relativeSrcFolders, { basePath
     const cache = new RuntimeCache();
     const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
     const functions = [...functionsMap.values()];
-    const augmentedFunctions = parseISC ? await Promise.all(functions.map((func) => augmentWithISC(func))) : functions;
+    const augmentedFunctions = parseISC
+        ? await Promise.all(functions.map((func) => augmentWithStaticAnalysis(func)))
+        : functions;
     const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
     return listedFunctionsFiles.flat();
 };
-const getListedFunction = function ({ config, extension, inSourceConfig, mainFile, name, runtime, }) {
+const getListedFunction = function ({ config, extension, staticAnalysisResult, mainFile, name, runtime, }) {
     return {
         displayName: config.name,
         extension,
@@ -65,15 +67,16 @@ const getListedFunction = function ({ config, extension, inSourceConfig, mainFil
         mainFile,
         name,
         runtime: runtime.name,
-        runtimeAPIVersion: inSourceConfig ? inSourceConfig?.runtimeAPIVersion ?? 1 : undefined,
-        schedule: inSourceConfig?.schedule ?? config.schedule,
+        runtimeAPIVersion: staticAnalysisResult ? staticAnalysisResult?.runtimeAPIVersion ?? 1 : undefined,
+        schedule: staticAnalysisResult?.schedule ?? config.schedule,
+        inputModuleFormat: staticAnalysisResult?.inputModuleFormat,
     };
 };
 const getListedFunctionFiles = async function (func, options) {
     const srcFiles = await getSrcFiles({
         ...func,
         ...options,
-        runtimeAPIVersion: func.inSourceConfig?.runtimeAPIVersion ?? 1,
+        runtimeAPIVersion: func.staticAnalysisResult?.runtimeAPIVersion ?? 1,
     });
     return srcFiles.map((srcFile) => ({ ...getListedFunction(func), srcFile, extension: extname(srcFile) }));
 };

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

@@ -6,6 +6,7 @@ import { FunctionBundlingUserError } from '../../../../utils/error.js';
 import { getPathWithExtension, safeUnlink } from '../../../../utils/fs.js';
 import { glob } from '../../../../utils/matching.js';
 import { RUNTIME } from '../../../runtime.js';
+import { CJS_SHIM } from '../../utils/esm_cjs_compat.js';
 import { getFileExtensionForFormat, MODULE_FORMAT } from '../../utils/module_format.js';
 import { NODE_BUNDLER } from '../types.js';
 import { getBundlerTarget, getModuleFormat } from './bundler_target.js';
@@ -88,19 +89,9 @@ export const bundleJsFile = async function ({ additionalModulePaths, config, ext
     });
     // The extension of the output file.
     const outputExtension = getFileExtensionForFormat(moduleFormat, featureFlags, runtimeAPIVersion);
-    // We add this banner so that calls to require() still work in ESM modules, especially when importing node built-ins
-    // We have to do this until this is fixed in esbuild: https://github.com/evanw/esbuild/pull/2067
-    const esmJSBanner = `
-import {createRequire as ___nfyCreateRequire} from "module";
-import {fileURLToPath as ___nfyFileURLToPath} from "url";
-import {dirname as ___nfyPathDirname} from "path";
-let __filename=___nfyFileURLToPath(import.meta.url);
-let __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));
-let require=___nfyCreateRequire(import.meta.url);
-`;
     try {
         const { metafile = { inputs: {}, outputs: {} }, warnings } = await build({
-            banner: moduleFormat === MODULE_FORMAT.ESM ? { js: esmJSBanner } : undefined,
+            banner: moduleFormat === MODULE_FORMAT.ESM ? { js: CJS_SHIM } : undefined,
             bundle: true,
             entryPoints: [srcFile],
             external,

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

@@ -22,18 +22,20 @@ export const getBundler = (name) => {
     }
 };
 export const getBundlerName = async ({ config: { nodeBundler }, extension, featureFlags, mainFile, runtimeAPIVersion, }) => {
+    // For V2 functions, we force the bundler to NFT. The only exception is when
+    // a `none` override was provided.
+    if (runtimeAPIVersion === 2) {
+        return nodeBundler === NODE_BUNDLER.NONE ? NODE_BUNDLER.NONE : NODE_BUNDLER.NFT;
+    }
     if (nodeBundler) {
         return nodeBundler;
     }
-    return await getDefaultBundler({ extension, featureFlags, mainFile, runtimeAPIVersion });
+    return await getDefaultBundler({ extension, featureFlags, mainFile });
 };
 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, runtimeAPIVersion, }) => {
-    if (runtimeAPIVersion === 2) {
-        return NODE_BUNDLER.NFT;
-    }
+const getDefaultBundler = async ({ extension, featureFlags, mainFile, }) => {
     if (extension === MODULE_FILE_EXTENSION.MJS && featureFlags.zisi_pure_esm_mjs) {
         return NODE_BUNDLER.NFT;
     }

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

@@ -8,14 +8,13 @@ import { filterExcludedPaths, getPathsOfIncludedFiles } from '../../utils/includ
 import { MODULE_FORMAT, MODULE_FILE_EXTENSION, tsExtensions } from '../../utils/module_format.js';
 import { getNodeSupportMatrix } from '../../utils/node_version.js';
 import { getClosestPackageJson } from '../../utils/package_json.js';
-import { getModuleFormat as getModuleFormatFromTsConfig } from '../../utils/tsconfig.js';
 import { processESM } from './es_modules.js';
 import { transpileTS } from './transpile.js';
 const appearsToBeModuleName = (name) => !name.startsWith('.');
 const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, runtimeAPIVersion, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { excludePatterns, paths: includedFilePaths } = await getPathsOfIncludedFiles(includedFiles, includedFilesBasePath || basePath);
-    const { aliases, mainFile: normalizedMainFile, moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
+    const { aliases, bundledPaths = [], mainFile: normalizedMainFile, moduleFormat, rewrites, tracedPaths, } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
         cache,
         config,
@@ -27,15 +26,18 @@ const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, p
         runtimeAPIVersion,
     });
     const includedPaths = filterExcludedPaths(includedFilePaths, excludePatterns);
-    const filteredIncludedPaths = [...filterExcludedPaths(dependencyPaths, excludePatterns), ...includedPaths];
+    const filteredIncludedPaths = [...filterExcludedPaths(tracedPaths, excludePatterns), ...includedPaths];
     const dirnames = filteredIncludedPaths.map((filePath) => normalize(dirname(filePath))).sort();
     // Sorting the array to make the checksum deterministic.
     const srcFiles = [...filteredIncludedPaths].sort();
+    // The inputs are the union of any traced paths (included as files in the end
+    // result) and any bundled paths (merged together in the bundle).
+    const inputs = bundledPaths.length === 0 ? tracedPaths : [...new Set([...tracedPaths, ...bundledPaths])];
     return {
         aliases,
         basePath: getBasePath(dirnames),
         includedFiles: includedPaths,
-        inputs: dependencyPaths,
+        inputs,
         mainFile: normalizedMainFile,
         moduleFormat,
         rewrites,
@@ -55,11 +57,17 @@ const getIgnoreFunction = (config) => {
  * Returns the module format that should be used when transpiling a TypeScript
  * file.
  */
-const getTSModuleFormat = async (mainFile, repositoryRoot) => {
-    const fromTsConfig = getModuleFormatFromTsConfig(mainFile, repositoryRoot);
-    // If we can infer the module type from a `tsconfig.json` file, use that.
-    if (fromTsConfig !== undefined) {
-        return fromTsConfig;
+const getTSModuleFormat = async (mainFile, runtimeAPIVersion, repositoryRoot) => {
+    // TODO: This check should go away. We should always respect the format from
+    // the extension. We'll do this at a later stage, after we roll out the V2
+    // API with no side-effects on V1 functions.
+    if (runtimeAPIVersion === 2) {
+        if (extname(mainFile) === MODULE_FILE_EXTENSION.MTS) {
+            return MODULE_FORMAT.ESM;
+        }
+        if (extname(mainFile) === MODULE_FILE_EXTENSION.CTS) {
+            return MODULE_FORMAT.COMMONJS;
+        }
     }
     // At this point, we need to infer the module type from the `type` field in
     // the closest `package.json`.
@@ -79,25 +87,28 @@ const getTypeScriptTransformer = async (runtimeAPIVersion, mainFile, repositoryR
     if (!isTypeScript) {
         return;
     }
+    const format = await getTSModuleFormat(mainFile, runtimeAPIVersion, repositoryRoot);
     const aliases = new Map();
     const rewrites = new Map();
-    // For functions using the V2 API, the format is always ESM.
+    const transformer = {
+        aliases,
+        format,
+        rewrites,
+    };
     if (runtimeAPIVersion === 2) {
+        // For V2 functions, we want to emit a main file with an unambiguous
+        // extension (i.e. `.cjs` or `.mjs`), so that the file is loaded with
+        // the correct format regardless of what is set in `package.json`.
+        const newExtension = format === MODULE_FORMAT.COMMONJS ? MODULE_FILE_EXTENSION.CJS : MODULE_FILE_EXTENSION.MJS;
+        const newMainFile = getPathWithExtension(mainFile, newExtension);
         return {
-            aliases,
+            ...transformer,
             bundle: true,
-            format: MODULE_FORMAT.ESM,
-            rewrites,
+            bundledPaths: [],
+            newMainFile,
         };
     }
-    // For functions using the V1 API, the format is inferred from the settings
-    // in `tsconfig.json` and `package.json`.
-    const format = await getTSModuleFormat(mainFile, repositoryRoot);
-    return {
-        aliases,
-        format,
-        rewrites,
-    };
+    return transformer;
 };
 const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, repositoryRoot, runtimeAPIVersion, }) {
     const tsTransformer = await getTypeScriptTransformer(runtimeAPIVersion, mainFile, repositoryRoot);
@@ -111,19 +122,29 @@ const traceFilesAndTranspile = async function ({ basePath, cache, config, featur
             try {
                 const extension = extname(path);
                 if (tsExtensions.has(extension)) {
-                    const transpiledSource = await transpileTS({
+                    const { bundledPaths, transpiled } = await transpileTS({
                         bundle: tsTransformer?.bundle,
                         config,
                         name,
                         format: tsTransformer?.format,
                         path,
                     });
-                    const newPath = getPathWithExtension(path, MODULE_FILE_EXTENSION.JS);
+                    const isMainFile = path === mainFile;
+                    // If this is the main file, the final path of the compiled file may
+                    // have been set by the transformer. It's fine to do this, since the
+                    // only place where this file will be imported from is our entry file
+                    // and we'll know the right path to use.
+                    const newPath = isMainFile && tsTransformer?.newMainFile
+                        ? tsTransformer.newMainFile
+                        : getPathWithExtension(path, MODULE_FILE_EXTENSION.JS);
                     // Overriding the contents of the `.ts` file.
-                    tsTransformer?.rewrites.set(path, transpiledSource);
+                    tsTransformer?.rewrites.set(path, transpiled);
                     // Rewriting the `.ts` path to `.js` in the bundle.
                     tsTransformer?.aliases.set(path, newPath);
-                    return transpiledSource;
+                    // Registering the input files that were bundled into the transpiled
+                    // file.
+                    tsTransformer?.bundledPaths?.push(...bundledPaths);
+                    return transpiled;
                 }
                 return await cachedReadFile(cache.fileCache, path);
             }
@@ -150,14 +171,15 @@ const traceFilesAndTranspile = async function ({ basePath, cache, config, featur
             }
         },
     });
-    const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? resolve(basePath, path) : resolve(path));
+    const normalizedTracedPaths = [...dependencyPaths].map((path) => (basePath ? resolve(basePath, path) : resolve(path)));
     if (tsTransformer) {
         return {
             aliases: tsTransformer.aliases,
-            mainFile: getPathWithExtension(mainFile, MODULE_FILE_EXTENSION.JS),
+            bundledPaths: tsTransformer.bundledPaths,
+            mainFile: tsTransformer.newMainFile ?? getPathWithExtension(mainFile, MODULE_FILE_EXTENSION.JS),
             moduleFormat: tsTransformer.format,
-            paths: normalizedDependencyPaths,
             rewrites: tsTransformer.rewrites,
+            tracedPaths: normalizedTracedPaths,
         };
     }
     const { moduleFormat, rewrites } = await processESM({
@@ -174,8 +196,8 @@ const traceFilesAndTranspile = async function ({ basePath, cache, config, featur
     return {
         mainFile,
         moduleFormat,
-        paths: normalizedDependencyPaths,
         rewrites,
+        tracedPaths: normalizedTracedPaths,
     };
 };
 const getSrcFiles = async function ({ basePath, config, mainFile }) {

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

@@ -1,13 +1,11 @@
 import type { FunctionConfig } from '../../../../config.js';
 import { ModuleFormat } from '../../utils/module_format.js';
-import type { TsConfig } from '../../utils/tsconfig.js';
 interface TranspileESMToCJSOptions {
     config: FunctionConfig;
     name: string;
     path: string;
-    tsConfig?: TsConfig;
 }
-export declare const transpileESMToCJS: ({ config, name, path, tsConfig }: TranspileESMToCJSOptions) => Promise<string>;
+export declare const transpileESMToCJS: ({ config, name, path }: TranspileESMToCJSOptions) => Promise<string>;
 interface TranspileTSOptions {
     bundle?: boolean;
     config: FunctionConfig;
@@ -15,5 +13,8 @@ interface TranspileTSOptions {
     name: string;
     path: string;
 }
-export declare const transpileTS: ({ bundle, config, format, name, path }: TranspileTSOptions) => Promise<string>;
+export declare const transpileTS: ({ bundle, config, format, name, path }: TranspileTSOptions) => Promise<{
+    bundledPaths: string[];
+    transpiled: string;
+}>;
 export {};

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

@@ -1,10 +1,12 @@
+import { resolve } from 'path';
 import { build } from 'esbuild';
 import { FunctionBundlingUserError } from '../../../../utils/error.js';
 import { RUNTIME } from '../../../runtime.js';
+import { CJS_SHIM } from '../../utils/esm_cjs_compat.js';
 import { MODULE_FORMAT } from '../../utils/module_format.js';
 import { getBundlerTarget } from '../esbuild/bundler_target.js';
 import { NODE_BUNDLER } from '../types.js';
-export const transpileESMToCJS = async ({ config, name, path, tsConfig }) => {
+export const transpileESMToCJS = async ({ config, name, path }) => {
     // The version of ECMAScript to use as the build target. This will determine
     // whether certain features are transpiled down or left untransformed.
     const nodeTarget = getBundlerTarget(config.nodeVersion);
@@ -17,7 +19,6 @@ export const transpileESMToCJS = async ({ config, name, path, tsConfig }) => {
             platform: 'node',
             sourcemap: Boolean(config.nodeSourcemap),
             target: [nodeTarget],
-            tsconfigRaw: tsConfig ? JSON.stringify(tsConfig) : undefined,
             write: false,
         });
         return transpiled.outputFiles[0].text;
@@ -34,19 +35,30 @@ export const transpileTS = async ({ bundle = false, config, format, name, path }
     // The version of ECMAScript to use as the build target. This will determine
     // whether certain features are transpiled down or left untransformed.
     const nodeTarget = getBundlerTarget(config.nodeVersion);
-    const bundleOptions = bundle ? { bundle: true, packages: 'external' } : { bundle: false };
+    const bundleOptions = {
+        bundle: false,
+    };
+    if (bundle) {
+        bundleOptions.bundle = true;
+        bundleOptions.packages = 'external';
+        if (format === MODULE_FORMAT.ESM) {
+            bundleOptions.banner = { js: CJS_SHIM };
+        }
+    }
     try {
         const transpiled = await build({
             ...bundleOptions,
             entryPoints: [path],
             format,
             logLevel: 'error',
+            metafile: true,
             platform: 'node',
             sourcemap: Boolean(config.nodeSourcemap),
             target: [nodeTarget],
             write: false,
         });
-        return transpiled.outputFiles[0].text;
+        const bundledPaths = bundle ? Object.keys(transpiled.metafile.inputs).map((inputPath) => resolve(inputPath)) : [];
+        return { bundledPaths, transpiled: transpiled.outputFiles[0].text };
     }
     catch (error) {
         throw FunctionBundlingUserError.addCustomErrorInfo(error, {

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

@@ -2,28 +2,45 @@ import type { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName
 import { InvocationMode } from '../../../function.js';
 import { Logger } from '../../../utils/logger.js';
 import { Route } from '../../../utils/routes.js';
+import type { ModuleFormat } from '../utils/module_format.js';
 export declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
 export type ISCValues = {
-    invocationMode?: InvocationMode;
     routes?: Route[];
-    runtimeAPIVersion?: number;
     schedule?: string;
     methods?: string[];
 };
+export interface StaticAnalysisResult extends ISCValues {
+    inputModuleFormat?: ModuleFormat;
+    invocationMode?: InvocationMode;
+    runtimeAPIVersion?: number;
+}
 interface FindISCDeclarationsOptions {
     functionName: string;
     logger: Logger;
 }
-export declare const findISCDeclarationsInPath: (sourcePath: string, { functionName, logger }: FindISCDeclarationsOptions) => Promise<ISCValues>;
-export declare const findISCDeclarations: (source: string, { functionName, logger }: FindISCDeclarationsOptions) => ISCValues;
+/**
+ * Loads a file at a given path, parses it into an AST, and returns a series of
+ * data points, such as in-source configuration properties and other metadata.
+ */
+export declare const parseFile: (sourcePath: string, { functionName, logger }: FindISCDeclarationsOptions) => Promise<StaticAnalysisResult>;
+/**
+ * Takes a JS/TS source as a string, parses it into an AST, and returns a
+ * series of data points, such as in-source configuration properties and
+ * other metadata.
+ */
+export declare const parseSource: (source: string, { functionName, logger }: FindISCDeclarationsOptions) => StaticAnalysisResult;
 export type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
 export type ISCExportWithCallExpression = {
     type: 'call-expression';
     args: ISCHandlerArg[];
     local: string;
 };
+export type ISCExportWithObject = {
+    type: 'object-expression';
+    object: Record<string, unknown>;
+};
 export type ISCExportOther = {
     type: 'other';
 };
-export type ISCExport = ISCExportWithCallExpression | ISCExportOther;
+export type ISCExport = ISCExportWithCallExpression | ISCExportWithObject | ISCExportOther;
 export {};

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

@@ -5,7 +5,7 @@ import { getRoutes } from '../../../utils/routes.js';
 import { RUNTIME } from '../../runtime.js';
 import { NODE_BUNDLER } from '../bundlers/types.js';
 import { createBindingsMethod } from '../parser/bindings.js';
-import { getExports } from '../parser/exports.js';
+import { traverseNodes } from '../parser/exports.js';
 import { getImports } from '../parser/imports.js';
 import { safelyParseSource, safelyReadSource } from '../parser/index.js';
 import { parse as parseSchedule } from './properties/schedule.js';
@@ -18,16 +18,6 @@ const validateScheduleFunction = (functionFound, scheduleFound, functionName) =>
         throw new FunctionBundlingUserError('Unable to find cron expression for scheduled function. The cron expression (first argument) for the `schedule` helper needs to be accessible inside the file and cannot be imported.', { functionName, runtime: RUNTIME.JAVASCRIPT });
     }
 };
-// Parses a JS/TS file and looks for in-source config declarations. It returns
-// an array of all declarations found, with `property` indicating the name of
-// the property and `data` its value.
-export const findISCDeclarationsInPath = async (sourcePath, { functionName, logger }) => {
-    const source = await safelyReadSource(sourcePath);
-    if (source === null) {
-        return {};
-    }
-    return findISCDeclarations(source, { functionName, logger });
-};
 /**
  * Normalizes method names into arrays of uppercase strings.
  * (e.g. "get" becomes ["GET"])
@@ -45,7 +35,23 @@ const normalizeMethods = (input, name) => {
         return method.toUpperCase();
     });
 };
-export const findISCDeclarations = (source, { functionName, logger }) => {
+/**
+ * Loads a file at a given path, parses it into an AST, and returns a series of
+ * data points, such as in-source configuration properties and other metadata.
+ */
+export const parseFile = async (sourcePath, { functionName, logger }) => {
+    const source = await safelyReadSource(sourcePath);
+    if (source === null) {
+        return {};
+    }
+    return parseSource(source, { functionName, logger });
+};
+/**
+ * Takes a JS/TS source as a string, parses it into an AST, and returns a
+ * series of data points, such as in-source configuration properties and
+ * other metadata.
+ */
+export const parseSource = (source, { functionName, logger }) => {
     const ast = safelyParseSource(source);
     if (ast === null) {
         return {};
@@ -55,21 +61,22 @@ export const findISCDeclarations = (source, { functionName, logger }) => {
     let scheduledFunctionFound = false;
     let scheduleFound = false;
     const getAllBindings = createBindingsMethod(ast.body);
-    const { configExport, defaultExport, handlerExports } = getExports(ast.body, getAllBindings);
-    const isV2API = handlerExports.length === 0 && defaultExport !== undefined;
+    const { configExport, handlerExports, hasDefaultExport, inputModuleFormat } = traverseNodes(ast.body, getAllBindings);
+    const isV2API = handlerExports.length === 0 && hasDefaultExport;
     if (isV2API) {
-        const config = {
+        const result = {
+            inputModuleFormat,
             runtimeAPIVersion: 2,
         };
         logger.system('detected v2 function');
         if (typeof configExport.schedule === 'string') {
-            config.schedule = configExport.schedule;
+            result.schedule = configExport.schedule;
         }
         if (configExport.method !== undefined) {
-            config.methods = normalizeMethods(configExport.method, functionName);
+            result.methods = normalizeMethods(configExport.method, functionName);
         }
-        config.routes = getRoutes(configExport.path, functionName, config.methods ?? []);
-        return config;
+        result.routes = getRoutes(configExport.path, functionName, result.methods ?? []);
+        return result;
     }
     const iscExports = handlerExports
         .map((node) => {
@@ -107,6 +114,6 @@ export const findISCDeclarations = (source, { functionName, logger }) => {
         validateScheduleFunction(scheduledFunctionFound, scheduleFound, functionName);
     }
     const mergedExports = iscExports.reduce((acc, obj) => ({ ...acc, ...obj }), {});
-    return { ...mergedExports, runtimeAPIVersion: 1 };
+    return { ...mergedExports, inputModuleFormat, runtimeAPIVersion: 1 };
 };
 //# sourceMappingURL=index.js.map

package/dist/runtimes/node/index.js

@@ -1,4 +1,4 @@
-import { join } from 'path';
+import { extname, join } from 'path';
 import { copyFile } from 'cp-file';
 import { INVOCATION_MODE } from '../../function.js';
 import getInternalValue from '../../utils/get_internal_value.js';
@@ -6,7 +6,8 @@ import { RUNTIME } from '../runtime.js';
 import { getBundler, getBundlerName } from './bundlers/index.js';
 import { NODE_BUNDLER } from './bundlers/types.js';
 import { findFunctionsInPaths, findFunctionInPath } from './finder.js';
-import { findISCDeclarationsInPath } from './in_source_config/index.js';
+import { parseFile } from './in_source_config/index.js';
+import { MODULE_FORMAT, MODULE_FILE_EXTENSION } from './utils/module_format.js';
 import { getNodeRuntime, getNodeRuntimeForV2 } from './utils/node_runtime.js';
 import { createAliases as createPluginsModulesPathAliases, getPluginsModulesPath } from './utils/plugin_modules_path.js';
 import { zipNodeJs } from './utils/zip.js';
@@ -33,8 +34,8 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         await copyFile(srcPath, destPath);
         return { config, path: destPath, entryFilename: '' };
     }
-    const inSourceConfig = await findISCDeclarationsInPath(mainFile, { functionName: name, logger });
-    const runtimeAPIVersion = inSourceConfig.runtimeAPIVersion === 2 ? 2 : 1;
+    const staticAnalysisResult = await parseFile(mainFile, { functionName: name, logger });
+    const runtimeAPIVersion = staticAnalysisResult.runtimeAPIVersion === 2 ? 2 : 1;
     const pluginsModulesPath = await getPluginsModulesPath(srcDir);
     const bundlerName = await getBundlerName({
         config,
@@ -83,7 +84,7 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
     await cleanupFunction?.();
     // Getting the invocation mode from ISC, in case the function is using the
     // `stream` helper.
-    let { invocationMode } = inSourceConfig;
+    let { invocationMode } = staticAnalysisResult;
     // If we're using the V2 API, force the invocation to "stream".
     if (runtimeAPIVersion === 2) {
         invocationMode = INVOCATION_MODE.Stream;
@@ -92,6 +93,7 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
     if (name.endsWith('-background')) {
         invocationMode = INVOCATION_MODE.Background;
     }
+    const outputModuleFormat = extname(finalMainFile) === MODULE_FILE_EXTENSION.MJS ? MODULE_FORMAT.ESM : MODULE_FORMAT.COMMONJS;
     return {
         bundler: bundlerName,
         bundlerWarnings,
@@ -101,8 +103,9 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         generator: config?.generator || getInternalValue(isInternal),
         inputs,
         includedFiles,
-        inSourceConfig,
+        staticAnalysisResult,
         invocationMode,
+        outputModuleFormat,
         nativeNodeModules,
         path: zipPath.path,
         runtimeVersion: runtimeAPIVersion === 2 ? getNodeRuntimeForV2(config.nodeVersion) : getNodeRuntime(config.nodeVersion),

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

@@ -1,8 +1,18 @@
-import type { ExportDefaultDeclaration, Statement } from '@babel/types';
+import type { Statement } from '@babel/types';
 import type { ISCExport } from '../in_source_config/index.js';
 import type { BindingMethod } from './bindings.js';
-export declare const getExports: (nodes: Statement[], getAllBindings: BindingMethod) => {
+/**
+ * Traverses a list of nodes and returns:
+ *
+ * 1. Named `config` object export (ESM or CJS)
+ * 2. Whether there is a default export (ESM or CJS)
+ * 3. Named `handler` function exports (ESM or CJS)
+ * 4. The module format syntax used in the file: if any `import` or `export`
+ *    declarations are found, this is ESM; if not, this is CJS
+ */
+export declare const traverseNodes: (nodes: Statement[], getAllBindings: BindingMethod) => {
     configExport: Record<string, unknown>;
-    defaultExport: ExportDefaultDeclaration | undefined;
     handlerExports: ISCExport[];
+    hasDefaultExport: boolean;
+    inputModuleFormat: "cjs";
 };

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

@@ -1,39 +1,59 @@
-import { isModuleExports } from './helpers.js';
-// Finds and returns the following types of exports in an AST:
-// 1. Named `handler` function exports
-// 2. Default function export
-// 3. Named `config` object export
-export const getExports = (nodes, getAllBindings) => {
+import { MODULE_FORMAT } from '../utils/module_format.js';
+import { isESMImportExport, isModuleExports } from './helpers.js';
+/**
+ * Traverses a list of nodes and returns:
+ *
+ * 1. Named `config` object export (ESM or CJS)
+ * 2. Whether there is a default export (ESM or CJS)
+ * 3. Named `handler` function exports (ESM or CJS)
+ * 4. The module format syntax used in the file: if any `import` or `export`
+ *    declarations are found, this is ESM; if not, this is CJS
+ */
+export const traverseNodes = (nodes, getAllBindings) => {
     const handlerExports = [];
     let configExport = {};
-    let defaultExport;
+    let hasDefaultExport = false;
+    let inputModuleFormat = MODULE_FORMAT.COMMONJS;
     nodes.forEach((node) => {
-        const esmExports = getMainExportFromESM(node, getAllBindings);
-        if (esmExports.length !== 0) {
-            handlerExports.push(...esmExports);
+        if (isESMImportExport(node)) {
+            inputModuleFormat = MODULE_FORMAT.ESM;
+        }
+        const esmHandlerExports = getNamedESMExport(node, 'handler', getAllBindings);
+        if (esmHandlerExports.length !== 0) {
+            handlerExports.push(...esmHandlerExports);
+            return;
+        }
+        const cjsHandlerExports = getCJSExports(node, 'handler');
+        if (cjsHandlerExports.length !== 0) {
+            handlerExports.push(...cjsHandlerExports);
+            return;
+        }
+        if (isESMDefaultExport(node)) {
+            hasDefaultExport = true;
             return;
         }
-        const cjsExports = getMainExportFromCJS(node);
-        if (cjsExports.length !== 0) {
-            handlerExports.push(...cjsExports);
+        const cjsDefaultExports = getCJSExports(node, 'default');
+        if (cjsDefaultExports.length !== 0) {
+            hasDefaultExport = true;
             return;
         }
-        if (isDefaultExport(node)) {
-            defaultExport = node;
+        const esmConfig = parseConfigESMExport(node);
+        if (esmConfig !== undefined) {
+            configExport = esmConfig;
             return;
         }
-        const config = parseConfigExport(node);
-        if (config !== undefined) {
-            configExport = config;
+        const cjsConfigExports = getCJSExports(node, 'config');
+        if (cjsConfigExports.length !== 0 && cjsConfigExports[0].type === 'object-expression') {
+            configExport = cjsConfigExports[0].object;
         }
     });
-    return { configExport, defaultExport, handlerExports };
+    return { configExport, handlerExports, hasDefaultExport, inputModuleFormat };
 };
 // Finds the main handler export in a CJS AST.
-const getMainExportFromCJS = (node) => {
+const getCJSExports = (node, name) => {
     const handlerPaths = [
-        ['module', 'exports', 'handler'],
-        ['exports', 'handler'],
+        ['module', 'exports', name],
+        ['exports', name],
     ];
     return handlerPaths.flatMap((handlerPath) => {
         if (!isModuleExports(node, handlerPath)) {
@@ -42,41 +62,50 @@ const getMainExportFromCJS = (node) => {
         return getExportsFromExpression(node.expression.right);
     });
 };
-// Finds the main handler export in an ESM AST.
-const getMainExportFromESM = (node, getAllBindings) => {
+/**
+ * Finds a named ESM export with a given name. It's capable of finding exports
+ * with a variable declaration (`export const foo = "bar"`), but also resolve
+ * bindings and find things like `const baz = "1"; export { baz as foo }`.
+ */
+const getNamedESMExport = (node, name, getAllBindings) => {
     if (node.type !== 'ExportNamedDeclaration' || node.exportKind !== 'value') {
         return [];
     }
     const { declaration, specifiers } = node;
     if (specifiers?.length > 0) {
-        return getExportsFromBindings(specifiers, getAllBindings);
+        return getExportsFromBindings(specifiers, name, getAllBindings);
     }
     if (declaration?.type !== 'VariableDeclaration') {
         return [];
     }
     const handlerDeclaration = declaration.declarations.find((childDeclaration) => {
         const { id, type } = childDeclaration;
-        return type === 'VariableDeclarator' && id.type === 'Identifier' && id.name === 'handler';
+        return type === 'VariableDeclarator' && id.type === 'Identifier' && id.name === name;
     });
     const exports = getExportsFromExpression(handlerDeclaration?.init);
     return exports;
 };
-// Check if the Node is an ExportSpecifier that has a named export called `handler`
-// either with Identifier `export { handler }`
-// or with StringLiteral `export { x as "handler" }`
-const isHandlerExport = (node) => {
+/**
+ * Check if the node is an `ExportSpecifier` that has a named export with
+ * the given name, either as:
+ * - `export { handler }`, or
+ * - `export { x as "handler" }`
+ */
+const isNamedExport = (node, name) => {
     const { type, exported } = node;
     return (type === 'ExportSpecifier' &&
-        ((exported.type === 'Identifier' && exported.name === 'handler') ||
-            (exported.type === 'StringLiteral' && exported.value === 'handler')));
+        ((exported.type === 'Identifier' && exported.name === name) ||
+            (exported.type === 'StringLiteral' && exported.value === name)));
 };
 // Returns whether a given node is a default export declaration.
-const isDefaultExport = (node) => node.type === 'ExportDefaultDeclaration';
-// Finds a `config` named export that maps to an object variable declaration,
-// like:
-//
-// export const config = { prop1: "value 1" }
-const parseConfigExport = (node) => {
+const isESMDefaultExport = (node) => node.type === 'ExportDefaultDeclaration';
+/**
+ * Finds a `config` named CJS export that maps to an object variable
+ * declaration, like:
+ *
+ * `export const config = { prop1: "value 1" }`
+ */
+const parseConfigESMExport = (node) => {
     if (node.type === 'ExportNamedDeclaration' &&
         node.declaration?.type === 'VariableDeclaration' &&
         node.declaration.declarations[0].type === 'VariableDeclarator' &&
@@ -131,12 +160,15 @@ const parsePrimitive = (exp) => {
         return null;
     }
 };
-// Tries to resolve the export from a binding (variable)
-// for example `let handler; handler = () => {}; export { handler }` would
-// resolve correctly to the handler function
-const getExportsFromBindings = (specifiers, getAllBindings) => {
-    const specifier = specifiers.find(isHandlerExport);
-    if (!specifier) {
+/**
+ * Tries to resolve the export with a given name from a binding (variable).
+ * For example, the following would resolve correctly to the handler function:
+ *
+ * `let handler; handler = () => {}; export { handler }`
+ */
+const getExportsFromBindings = (specifiers, name, getAllBindings) => {
+    const specifier = specifiers.find((node) => isNamedExport(node, name));
+    if (!specifier || specifier.type !== 'ExportSpecifier') {
         return [];
     }
     const binding = getAllBindings().get(specifier.local.name);
@@ -152,6 +184,10 @@ const getExportsFromExpression = (node) => {
             }
             return [{ args, local: callee.name, type: 'call-expression' }];
         }
+        case 'ObjectExpression': {
+            const object = parseObject(node);
+            return [{ object, type: 'object-expression' }];
+        }
         default: {
             if (node !== undefined) {
                 return [{ type: 'other' }];

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

@@ -1,4 +1,5 @@
 import type { AssignmentExpression, Expression, ExpressionStatement, ImportDeclaration, Statement } from '@babel/types';
+export declare const isESMImportExport: (node: Statement) => boolean;
 export declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
 export declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
     expression: AssignmentExpression;

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

@@ -12,6 +12,10 @@ const isDotExpression = (node, expression) => {
     }
     return node.object.type === 'Identifier' && object[0] === node.object.name && property === node.property.name;
 };
+export const isESMImportExport = (node) => node.type === 'ImportDeclaration' ||
+    node.type === 'ExportNamedDeclaration' ||
+    node.type === 'ExportDefaultDeclaration' ||
+    node.type === 'ExportAllDeclaration';
 export const isImport = (node, importPath) => node.type === 'ImportDeclaration' && node.source.value === importPath;
 export const isModuleExports = (node, dotExpression = ['module', 'exports']) => node.type === 'ExpressionStatement' &&
     node.expression.type === 'AssignmentExpression' &&

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

@@ -0,0 +1,7 @@
+/**
+ * This shim makes calls to `require`, `__filename` and `__dirname` work when
+ * bundling to ESM with esbuild.
+ *
+ * https://github.com/evanw/esbuild/pull/2067
+ */
+export declare const CJS_SHIM = "\nimport {createRequire as ___nfyCreateRequire} from \"module\";\nimport {fileURLToPath as ___nfyFileURLToPath} from \"url\";\nimport {dirname as ___nfyPathDirname} from \"path\";\nlet __filename=___nfyFileURLToPath(import.meta.url);\nlet __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));\nlet require=___nfyCreateRequire(import.meta.url);\n";

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

@@ -0,0 +1,15 @@
+/**
+ * This shim makes calls to `require`, `__filename` and `__dirname` work when
+ * bundling to ESM with esbuild.
+ *
+ * https://github.com/evanw/esbuild/pull/2067
+ */
+export const CJS_SHIM = `
+import {createRequire as ___nfyCreateRequire} from "module";
+import {fileURLToPath as ___nfyFileURLToPath} from "url";
+import {dirname as ___nfyPathDirname} from "path";
+let __filename=___nfyFileURLToPath(import.meta.url);
+let __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));
+let require=___nfyCreateRequire(import.meta.url);
+`;
+//# sourceMappingURL=esm_cjs_compat.js.map

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

@@ -8,8 +8,10 @@ export declare const MODULE_FORMAT: {
 export type ModuleFormat = ObjectValues<typeof MODULE_FORMAT>;
 export declare const MODULE_FILE_EXTENSION: {
     readonly CJS: ".cjs";
+    readonly CTS: ".cts";
     readonly JS: ".js";
     readonly MJS: ".mjs";
+    readonly MTS: ".mts";
 };
 export type ModuleFileExtension = ObjectValues<typeof MODULE_FILE_EXTENSION>;
 export declare const getFileExtensionForFormat: (moduleFormat: ModuleFormat, featureFlags: FeatureFlags, runtimeAPIVersion: number) => ModuleFileExtension;

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

@@ -5,8 +5,10 @@ export const MODULE_FORMAT = {
 };
 export const MODULE_FILE_EXTENSION = {
     CJS: '.cjs',
+    CTS: '.cts',
     JS: '.js',
     MJS: '.mjs',
+    MTS: '.mts',
 };
 export const getFileExtensionForFormat = (moduleFormat, featureFlags, runtimeAPIVersion) => {
     if (moduleFormat === MODULE_FORMAT.ESM && (runtimeAPIVersion === 2 || featureFlags.zisi_pure_esm_mjs)) {

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

@@ -1,18 +1,14 @@
 import { Buffer } from 'buffer';
 import { mkdir, rm, writeFile } from 'fs/promises';
 import os from 'os';
-import { basename, dirname, extname, join } from 'path';
+import { basename, extname, join } from 'path';
 import { getPath as getV2APIPath } from '@netlify/serverless-functions-api';
 import { copyFile } from 'cp-file';
 import pMap from 'p-map';
 import { startZip, addZipFile, addZipContent, endZip, ARCHIVE_FORMAT, } from '../../../archive.js';
-import { FunctionBundlingUserError } from '../../../utils/error.js';
 import { cachedLstat, mkdirAndWriteFile } from '../../../utils/fs.js';
-import { RUNTIME } from '../../runtime.js';
 import { BOOTSTRAP_FILE_NAME, conflictsWithEntryFile, getEntryFile, isNamedLikeEntryFile, } from './entry_file.js';
-import { tsExtensions, MODULE_FORMAT } from './module_format.js';
 import { normalizeFilePath } from './normalize_path.js';
-import { getClosestPackageJson } from './package_json.js';
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
 // Sub-directory to place all user-defined files  (i.e. everything other than
@@ -26,7 +22,7 @@ const addBootstrapFile = function (srcFiles, aliases) {
     srcFiles.push(v2APIPath);
     aliases.set(v2APIPath, BOOTSTRAP_FILE_NAME);
 };
-const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, name, repositoryRoot, rewrites = new Map(), runtimeAPIVersion, srcFiles, }) {
+const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites = new Map(), runtimeAPIVersion, srcFiles, }) {
     const { contents: entryContents, filename: entryFilename } = getEntryFile({
         commonPrefix: basePath,
         featureFlags,
@@ -59,22 +55,9 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
         }
         return copyFile(srcFile, absoluteDestPath);
     }, { concurrency: COPY_FILE_CONCURRENCY });
-    if (tsExtensions.has(extension) && moduleFormat === MODULE_FORMAT.ESM && runtimeAPIVersion === 2) {
-        const packageJSON = await ensurePackageJSONWithModuleType({
-            basePath,
-            mainFile,
-            name,
-            repositoryRoot,
-            userNamespace: DEFAULT_USER_SUBDIRECTORY,
-        });
-        if (packageJSON) {
-            const absoluteDestPath = join(functionFolder, packageJSON.path);
-            await writeFile(absoluteDestPath, packageJSON.contents);
-        }
-    }
     return { path: functionFolder, entryFilename };
 };
-const createZipArchive = async function ({ aliases = new Map(), basePath, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, name, repositoryRoot, rewrites, runtimeAPIVersion, srcFiles, }) {
+const createZipArchive = async function ({ aliases = new Map(), basePath, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, runtimeAPIVersion, srcFiles, }) {
     const destPath = join(destFolder, `${basename(filename, extension)}.zip`);
     const { archive, output } = startZip(destPath);
     // There is a naming conflict with the entry file if one of the supporting
@@ -114,18 +97,6 @@ const createZipArchive = async function ({ aliases = new Map(), basePath, cache,
     if (runtimeAPIVersion === 2) {
         addBootstrapFile(srcFiles, aliases);
     }
-    if (tsExtensions.has(extension) && moduleFormat === MODULE_FORMAT.ESM && runtimeAPIVersion === 2) {
-        const packageJSON = await ensurePackageJSONWithModuleType({
-            basePath,
-            mainFile,
-            name,
-            repositoryRoot,
-            userNamespace,
-        });
-        if (packageJSON) {
-            addZipContent(archive, packageJSON.contents, packageJSON.path);
-        }
-    }
     const deduplicatedSrcFiles = [...new Set(srcFiles)];
     const srcFilesInfos = await Promise.all(deduplicatedSrcFiles.map((file) => addStat(cache, file)));
     // We ensure this is not async, so that the archive's checksum is
@@ -158,40 +129,6 @@ const addStat = async function (cache, srcFile) {
     const stat = await cachedLstat(cache.lstatCache, srcFile);
     return { srcFile, stat };
 };
-const ensurePackageJSONWithModuleType = async function ({ basePath, mainFile, name, repositoryRoot, userNamespace, }) {
-    const functionDirectory = dirname(mainFile);
-    let packageJSON = null;
-    try {
-        packageJSON = await getClosestPackageJson(functionDirectory, repositoryRoot);
-    }
-    catch {
-        // There is no valid `package.json`. This is a no-op.
-    }
-    // If the closest `package.json` already has a `module` type, there's nothing
-    // else we need to do.
-    if (packageJSON?.contents?.type === 'module') {
-        return;
-    }
-    // If there is already a `package.json` adjacent to the function entry point,
-    // we won't simply overwrite it because that might cause unexpected problems.
-    // Instead, we fail the build and tell the user that we found contradictory
-    // configuration settings.
-    if (packageJSON !== null && dirname(packageJSON.path) === functionDirectory) {
-        throw new FunctionBundlingUserError(`The function defined in '${mainFile}' has a contradictory configuration: a 'tsconfig.json' file is defining the module format as ESM, but '${packageJSON.path}' specifies CommonJS. If you want to use ESM, consider adding '"type": "module"' to 'package.json'; if you'd like to use CommonJS, consider setting the 'compilerOptions.module' property in 'tsconfig.json' to 'commonjs'.`, {
-            functionName: name,
-            runtime: RUNTIME.JAVASCRIPT,
-        });
-    }
-    // To ensure that the entry file and any local imports run as ESM, plant a
-    // `package.json` with `"type": "module"` adjacent to the entry point.
-    const path = join(functionDirectory, 'package.json');
-    const normalizedPath = normalizeFilePath({ commonPrefix: basePath, path, userNamespace });
-    const contents = JSON.stringify({ type: 'module' });
-    return {
-        contents,
-        path: normalizedPath,
-    };
-};
 const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrites = new Map(), stat, srcFile, userNamespace, }) {
     const destPath = aliases.get(srcFile) || srcFile;
     const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, userNamespace });

package/dist/runtimes/runtime.d.ts

@@ -2,11 +2,12 @@ import type { ArchiveFormat } from '../archive.js';
 import type { FunctionConfig } from '../config.js';
 import type { FeatureFlags } from '../feature_flags.js';
 import type { FunctionSource, InvocationMode, SourceFile } from '../function.js';
+import type { ModuleFormat } from '../main.js';
 import { ObjectValues } from '../types/utils.js';
 import type { RuntimeCache } from '../utils/cache.js';
 import { Logger } from '../utils/logger.js';
 import type { NodeBundlerName } from './node/bundlers/types.js';
-import type { ISCValues } from './node/in_source_config/index.js';
+import type { StaticAnalysisResult } from './node/in_source_config/index.js';
 export declare const RUNTIME: {
     readonly GO: "go";
     readonly JAVASCRIPT: "js";
@@ -39,11 +40,12 @@ export interface ZipFunctionResult {
     generator?: string;
     inputs?: string[];
     includedFiles?: string[];
-    inSourceConfig?: ISCValues;
     invocationMode?: InvocationMode;
+    outputModuleFormat?: ModuleFormat;
     nativeNodeModules?: object;
     path: string;
     runtimeVersion?: string;
+    staticAnalysisResult?: StaticAnalysisResult;
     entryFilename: string;
 }
 export type ZipFunction = (args: {

package/dist/utils/format_result.js

@@ -3,11 +3,11 @@ import { removeUndefined } from './remove_undefined.js';
 export const formatZipResult = (archive) => {
     const functionResult = {
         ...archive,
-        inSourceConfig: undefined,
-        routes: archive.inSourceConfig?.routes,
+        staticAnalysisResult: undefined,
+        routes: archive.staticAnalysisResult?.routes,
         runtime: archive.runtime.name,
-        schedule: archive.inSourceConfig?.schedule ?? archive?.config?.schedule,
-        runtimeAPIVersion: archive.inSourceConfig?.runtimeAPIVersion,
+        schedule: archive.staticAnalysisResult?.schedule ?? archive?.config?.schedule,
+        runtimeAPIVersion: archive.staticAnalysisResult?.runtimeAPIVersion,
     };
     return removeUndefined(functionResult);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "9.20.0",
+  "version": "9.22.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -66,7 +66,6 @@
     "execa": "^6.0.0",
     "filter-obj": "^5.0.0",
     "find-up": "^6.0.0",
-    "get-tsconfig": "^4.6.2",
     "glob": "^8.0.3",
     "is-builtin-module": "^3.1.0",
     "is-path-inside": "^4.0.0",
@@ -96,12 +95,12 @@
     "@types/is-ci": "3.0.1",
     "@types/node": "14.18.63",
     "@types/normalize-path": "3.0.0",
-    "@types/resolve": "1.20.2",
-    "@types/semver": "7.5.2",
+    "@types/resolve": "1.20.3",
+    "@types/semver": "7.5.3",
     "@types/tmp": "0.2.4",
     "@types/unixify": "1.0.0",
-    "@types/yargs": "17.0.24",
-    "@vitest/coverage-v8": "0.34.4",
+    "@types/yargs": "17.0.28",
+    "@vitest/coverage-v8": "0.34.6",
     "adm-zip": "0.5.10",
     "browserslist": "4.21.11",
     "cardinal": "2.1.1",
@@ -113,7 +112,7 @@
     "npm-run-all": "4.1.5",
     "source-map-support": "0.5.21",
     "typescript": "5.2.2",
-    "vitest": "0.34.4"
+    "vitest": "0.34.6"
   },
   "engines": {
     "node": "^14.18.0 || >=16.0.0"

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

@@ -1,7 +0,0 @@
-export type { TsConfigJson as TsConfig } from 'get-tsconfig';
-/**
- * Looks for a `tsconfig.json` file on a given path and, if one exists, returns
- * the module format inferred from the `module` property. If no file is found
- * or if no `module` property is defined, the function returns `undefined`.
- */
-export declare const getModuleFormat: (path: string, boundary?: string) => "cjs" | "esm" | undefined;

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

@@ -1,38 +0,0 @@
-import { dirname, relative } from 'path';
-import { getTsconfig } from 'get-tsconfig';
-import { MODULE_FORMAT } from './module_format.js';
-const esmModuleValues = new Set(['es6', 'es2015', 'es2020', 'es2022', 'esnext', 'node16', 'nodenext']);
-/**
- * Looks for a `tsconfig.json` file applicable to a given path and returns the
- * contents as an object. If a boundary is set, we'll stop traversing the file
- * system once that path is reached.
- */
-const getTSConfigInProject = (path, boundary) => {
-    const file = getTsconfig(path);
-    if (!file) {
-        return;
-    }
-    // If there is a boundary defined and the file we found is outside of it,
-    // discard the file.
-    if (boundary !== undefined && relative(boundary, dirname(file.path)).startsWith('..')) {
-        return;
-    }
-    return file.config;
-};
-/**
- * Looks for a `tsconfig.json` file on a given path and, if one exists, returns
- * the module format inferred from the `module` property. If no file is found
- * or if no `module` property is defined, the function returns `undefined`.
- */
-export const getModuleFormat = (path, boundary) => {
-    const config = getTSConfigInProject(path, boundary);
-    if (!config) {
-        return;
-    }
-    const moduleProp = config.compilerOptions?.module;
-    if (!moduleProp) {
-        return;
-    }
-    return esmModuleValues.has(moduleProp) ? MODULE_FORMAT.ESM : MODULE_FORMAT.COMMONJS;
-};
-//# sourceMappingURL=tsconfig.js.map