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

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

@@ -7,7 +7,7 @@ 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");
+const main_js_1 = require("./main.js");
 // CLI entry point
 const runCli = async function () {
     // @ts-expect-error TODO: `destFolder` and  `srcFolder` are not being passed
@@ -15,7 +15,7 @@ const runCli = async function () {
     const { destFolder, srcFolder, ...options } = parseArgs();
     try {
         // @ts-expect-error TODO: `options` is not getting the right types.
-        const zipped = await (0, main_1.zipFunctions)(srcFolder, destFolder, options);
+        const zipped = await (0, main_js_1.zipFunctions)(srcFolder, destFolder, options);
         console.log(JSON.stringify(zipped, null, 2));
     }
     catch (error) {

package/dist/config.d.ts

@@ -1,7 +1,7 @@
-import { FunctionSource } from './function';
-import type { NodeVersionString } from './runtimes/node';
-import type { NodeBundlerName } from './runtimes/node/bundlers';
-interface FunctionConfig {
+import { FunctionSource } from './function.js';
+import type { NodeBundlerName } from './runtimes/node/bundlers/index.js';
+import type { NodeVersionString } from './runtimes/node/index.js';
+export interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
     includedFilesBasePath?: string;
@@ -15,10 +15,9 @@ interface FunctionConfig {
     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,17 +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_detect_esm: 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

@@ -1,14 +1,14 @@
 /// <reference types="node" />
 import { Stats } from 'fs';
-import type { FunctionConfig } from './config';
-import type { Runtime, ZipFunctionResult } from './runtimes/runtime';
-declare type FunctionArchive = ZipFunctionResult & {
+import type { FunctionConfig } from './config.js';
+import type { Runtime, ZipFunctionResult } from './runtimes/runtime.js';
+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';
+import { Config } from './config.js';
+import { FeatureFlags } from './feature_flags.js';
+import { RuntimeName } from './runtimes/runtime.js';
+export { zipFunction, zipFunctions } from './zip.js';
 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,25 +1,28 @@
 "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");
+const feature_flags_js_1 = require("./feature_flags.js");
+const index_js_1 = require("./runtimes/index.js");
+const index_js_2 = require("./runtimes/node/in_source_config/index.js");
+const fs_js_1 = require("./utils/fs.js");
+var zip_js_1 = require("./zip.js");
+Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_js_1.zipFunction; } });
+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') {
         return func;
     }
-    const inSourceConfig = await (0, in_source_config_1.findISCDeclarationsInPath)(func.mainFile);
+    const inSourceConfig = await (0, index_js_2.findISCDeclarationsInPath)(func.mainFile);
     return { ...func, inSourceConfig };
 };
 // List all Netlify Functions main entry files for a specific directory
 const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
-    const paths = await (0, fs_1.listFunctionsDirectories)(srcFolders);
-    const functionsMap = await (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags, config });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const paths = await (0, fs_js_1.listFunctionsDirectories)(srcFolders);
+    const functionsMap = await (0, index_js_1.getFunctionsFromPaths)(paths, { featureFlags, config });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     return augmentedFunctions.map(getListedFunction);
@@ -27,8 +30,8 @@ const listFunctions = async function (relativeSrcFolders, { featureFlags: inputF
 exports.listFunctions = listFunctions;
 // Finds a function at a specific path.
 const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const func = await (0, runtimes_1.getFunctionFromPath)(path, { featureFlags, config });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const func = await (0, index_js_1.getFunctionFromPath)(path, { featureFlags, config });
     if (!func) {
         return;
     }
@@ -38,10 +41,10 @@ const listFunction = async function (path, { featureFlags: inputFeatureFlags, co
 exports.listFunction = listFunction;
 // List all Netlify Functions files for a specific directory
 const listFunctionsFiles = async function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
-    const paths = await (0, fs_1.listFunctionsDirectories)(srcFolders);
-    const functionsMap = await (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const paths = await (0, fs_js_1.listFunctionsDirectories)(srcFolders);
+    const functionsMap = await (0, index_js_1.getFunctionsFromPaths)(paths, { config, featureFlags });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
@@ -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

@@ -1,4 +1,4 @@
-import { FunctionResult } from './utils/format_result';
+import { FunctionResult } from './utils/format_result.js';
 interface ManifestFunction {
     mainFile: string;
     name: string;
@@ -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, }: {
+import { FsCache } from '../utils/fs.js';
+import type { RuntimeName } from './runtime.js';
+export declare const detectBinaryRuntime: ({ fsCache, path, }: {
     fsCache: FsCache;
     path: string;
 }) => Promise<RuntimeName | undefined>;
-export { detectBinaryRuntime };

package/dist/runtimes/detect_runtime.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectBinaryRuntime = void 0;
 const elf_cam_1 = require("elf-cam");
-const fs_1 = require("../utils/fs");
+const fs_js_1 = require("../utils/fs.js");
 // Try to guess the runtime by inspecting the binary file.
 const detectBinaryRuntime = async function ({ fsCache, path, }) {
     try {
-        const buffer = await (0, fs_1.cachedReadFile)(fsCache, path);
+        const buffer = await (0, fs_js_1.cachedReadFile)(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.

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

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const shell_1 = require("../../utils/shell");
+const shell_js_1 = require("../../utils/shell.js");
 const build = async ({ destPath, mainFile, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
     try {
-        await shell_1.shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+        await shell_js_1.shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
             cwd: srcDir,
             env: {
                 CGO_ENABLED: '0',

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

@@ -1,3 +1,3 @@
-import { Runtime } from '../runtime';
+import { Runtime } from '../runtime.js';
 declare const runtime: Runtime;
 export default runtime;

package/dist/runtimes/go/index.js

@@ -5,20 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
-const fs_1 = require("../../utils/fs");
-const non_nullable_1 = require("../../utils/non_nullable");
-const zip_binary_1 = require("../../zip_binary");
-const detect_runtime_1 = require("../detect_runtime");
-const builder_1 = require("./builder");
+const fs_js_1 = require("../../utils/fs.js");
+const non_nullable_js_1 = require("../../utils/non_nullable.js");
+const zip_binary_js_1 = require("../../zip_binary.js");
+const detect_runtime_js_1 = require("../detect_runtime.js");
+const builder_js_1 = require("./builder.js");
 const detectGoFunction = async ({ fsCache, path }) => {
-    const stat = await (0, fs_1.cachedLstat)(fsCache, path);
+    const stat = await (0, fs_js_1.cachedLstat)(fsCache, path);
     if (!stat.isDirectory()) {
         return;
     }
     const directoryName = (0, path_1.basename)(path);
     // @ts-expect-error TODO: The `makeCachedFunction` abstraction is causing the
     // return value of `readdir` to be incorrectly typed.
-    const files = (await (0, fs_1.cachedReaddir)(fsCache, path));
+    const files = (await (0, fs_js_1.cachedReaddir)(fsCache, path));
     const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name));
     if (mainFileName === undefined) {
         return;
@@ -27,10 +27,10 @@ const detectGoFunction = async ({ fsCache, path }) => {
 };
 const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
     const functions = await Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
-    return functions.filter(non_nullable_1.nonNullable);
+    return functions.filter(non_nullable_js_1.nonNullable);
 };
 const findFunctionInPath = async function ({ featureFlags, fsCache, path }) {
-    const runtime = await (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+    const runtime = await (0, detect_runtime_js_1.detectBinaryRuntime)({ fsCache, path });
     if (runtime === 'go') {
         return processBinary({ fsCache, path });
     }
@@ -43,7 +43,7 @@ const findFunctionInPath = async function ({ featureFlags, fsCache, path }) {
     }
 };
 const processBinary = async ({ fsCache, path }) => {
-    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
+    const stat = (await (0, fs_js_1.cachedLstat)(fsCache, path));
     const extension = (0, path_1.extname)(path);
     const filename = (0, path_1.basename)(path);
     const name = (0, path_1.basename)(path, (0, path_1.extname)(path));
@@ -62,7 +62,7 @@ const processSource = async ({ fsCache, mainFile, path, }) => {
     // the `FunctionSource` interface. We should revisit whether `stat` should be
     // part of that interface in the first place, or whether we could compute it
     // downstream when needed (maybe using the FS cache as an optimisation).
-    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
+    const stat = (await (0, fs_js_1.cachedLstat)(fsCache, path));
     const filename = (0, path_1.basename)(path);
     const extension = (0, path_1.extname)(mainFile);
     const name = (0, path_1.basename)(path, (0, path_1.extname)(path));
@@ -86,7 +86,7 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
     // If we're building a Go function from source, we call the build method and
     // update `binary` to point to the newly-created binary.
     if (isSource) {
-        const { stat: binaryStat } = await (0, builder_1.build)({ destPath, mainFile, srcDir });
+        const { stat: binaryStat } = await (0, builder_js_1.build)({ destPath, mainFile, srcDir });
         binary = {
             path: destPath,
             stat: binaryStat,
@@ -101,7 +101,7 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
             filename: (0, path_1.basename)(destPath),
             runtime,
         };
-        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath: binary.path, stat: binary.stat });
+        await (0, zip_binary_js_1.zipBinary)({ ...zipOptions, srcPath: binary.path, stat: binary.stat });
         return { config, path: zipPath };
     }
     // We don't need to zip the binary, so we can just copy it to the right path.

package/dist/runtimes/index.d.ts

@@ -1,11 +1,11 @@
-import { Config } from '../config';
-import { FeatureFlags } from '../feature_flags';
-import { FunctionSource } from '../function';
+import { Config } from '../config.js';
+import { FeatureFlags } from '../feature_flags.js';
+import { FunctionSource } from '../function.js';
 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/index.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFunctionFromPath = exports.getFunctionsFromPaths = void 0;
 const path_1 = require("path");
-const config_1 = require("../config");
-const feature_flags_1 = require("../feature_flags");
-const go_1 = __importDefault(require("./go"));
-const node_1 = __importDefault(require("./node"));
-const rust_1 = __importDefault(require("./rust"));
+const config_js_1 = require("../config.js");
+const feature_flags_js_1 = require("../feature_flags.js");
+const index_js_1 = __importDefault(require("./go/index.js"));
+const index_js_2 = __importDefault(require("./node/index.js"));
+const index_js_3 = __importDefault(require("./rust/index.js"));
 /**
  * Finds functions for a list of paths using a specific runtime. The return
  * value is an object containing an array of the functions found (`functions`)
@@ -43,11 +43,11 @@ const makeFsCache = () => ({});
 // The order of this array determines the priority of the runtimes. If a path
 // is used by the first time, it won't be made available to the subsequent
 // runtimes.
-const RUNTIMES = [node_1.default, go_1.default, rust_1.default];
+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_1.defaultFlags, } = {}) => {
+const getFunctionsFromPaths = async (paths, { config, 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
@@ -69,7 +69,7 @@ const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFla
     }, Promise.resolve({ functions: [], remainingPaths: paths }));
     const functionsWithConfig = functions.map(([name, func]) => [
         name,
-        { ...func, config: (0, config_1.getConfigForFunction)({ config, func }) },
+        { ...func, config: (0, config_js_1.getConfigForFunction)({ config, func }) },
     ]);
     return new Map(functionsWithConfig);
 };
@@ -77,7 +77,7 @@ exports.getFunctionsFromPaths = getFunctionsFromPaths;
 /**
  * Gets a list of functions found in a list of paths.
  */
-const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_1.defaultFlags } = {}) => {
+const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_js_1.defaultFlags } = {}) => {
     const fsCache = makeFsCache();
     for (const runtime of RUNTIMES) {
         const func = await runtime.findFunctionInPath({ path, fsCache, featureFlags });
@@ -85,7 +85,7 @@ const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_
             return {
                 ...func,
                 runtime,
-                config: (0, config_1.getConfigForFunction)({ config, func: { ...func, runtime } }),
+                config: (0, config_js_1.getConfigForFunction)({ config, func: { ...func, runtime } }),
             };
         }
     }

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

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