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

package/dist/runtimes/node/index.js

@@ -5,28 +5,28 @@ 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 bundlers_1 = require("./bundlers");
-const finder_1 = require("./finder");
-const in_source_config_1 = require("./in_source_config");
-const plugin_modules_path_1 = require("./utils/plugin_modules_path");
-const zip_1 = require("./utils/zip");
+const index_js_1 = require("./bundlers/index.js");
+const finder_js_1 = require("./finder.js");
+const index_js_2 = require("./in_source_config/index.js");
+const plugin_modules_path_js_1 = require("./utils/plugin_modules_path.js");
+const zip_js_1 = require("./utils/zip.js");
 // A proxy for the `getSrcFiles` function which adds a default `bundler` using
 // the `getDefaultBundler` function.
 const getSrcFilesWithBundler = async (parameters) => {
-    const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(parameters.srcDir);
+    const pluginsModulesPath = await (0, plugin_modules_path_js_1.getPluginsModulesPath)(parameters.srcDir);
     const bundlerName = parameters.config.nodeBundler ||
-        (await (0, bundlers_1.getDefaultBundler)({
+        (await (0, index_js_1.getDefaultBundler)({
             extension: parameters.extension,
             featureFlags: parameters.featureFlags,
             mainFile: parameters.mainFile,
         }));
-    const bundler = (0, bundlers_1.getBundler)(bundlerName);
+    const bundler = (0, index_js_1.getBundler)(bundlerName);
     return bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
 };
 const zipFunction = async function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
-    const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(srcDir);
-    const bundlerName = config.nodeBundler || (await (0, bundlers_1.getDefaultBundler)({ extension, mainFile, featureFlags }));
-    const bundler = (0, bundlers_1.getBundler)(bundlerName);
+    const pluginsModulesPath = await (0, plugin_modules_path_js_1.getPluginsModulesPath)(srcDir);
+    const bundlerName = config.nodeBundler || (await (0, index_js_1.getDefaultBundler)({ extension, mainFile, featureFlags }));
+    const bundler = (0, index_js_1.getBundler)(bundlerName);
     // If the file is a zip, we assume the function is bundled and ready to go.
     // We simply copy it to the destination path with no further processing.
     if (extension === '.zip') {
@@ -49,9 +49,9 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         srcPath,
         stat,
     });
-    const inSourceConfig = await (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
-    (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
-    const zipPath = await (0, zip_1.zipNodeJs)({
+    const inSourceConfig = await (0, index_js_2.findISCDeclarationsInPath)(mainFile);
+    (0, plugin_modules_path_js_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
+    const zipPath = await (0, zip_js_1.zipNodeJs)({
         aliases,
         archiveFormat,
         basePath: finalBasePath,
@@ -96,8 +96,8 @@ const zipWithFunctionWithFallback = async ({ config = {}, ...parameters }) => {
     }
 };
 const runtime = {
-    findFunctionsInPaths: finder_1.findFunctionsInPaths,
-    findFunctionInPath: finder_1.findFunctionInPath,
+    findFunctionsInPaths: finder_js_1.findFunctionsInPaths,
+    findFunctionInPath: finder_js_1.findFunctionInPath,
     getSrcFiles: getSrcFilesWithBundler,
     name: 'js',
     zipFunction: zipWithFunctionWithFallback,

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

@@ -1,3 +1,3 @@
 import { Statement } from '@babel/types';
-import type { ISCExport } from '../in_source_config';
+import type { ISCExport } from '../in_source_config/index.js';
 export declare const getMainExport: (nodes: Statement[]) => ISCExport[];

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMainExport = void 0;
-const helpers_1 = require("./helpers");
+const helpers_js_1 = require("./helpers.js");
 // Finds the main handler export in an AST.
 const getMainExport = (nodes) => {
     let handlerExport = [];
@@ -28,7 +28,7 @@ const getMainExportFromCJS = (node) => {
         ['exports', 'handler'],
     ];
     return handlerPaths.flatMap((handlerPath) => {
-        if (!(0, helpers_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+        if (!(0, helpers_js_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
             return [];
         }
         return getExportsFromCallExpression(node.expression.right);

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getImports = void 0;
-const non_nullable_1 = require("../../../utils/non_nullable");
-const helpers_1 = require("./helpers");
+const non_nullable_js_1 = require("../../../utils/non_nullable.js");
+const helpers_js_1 = require("./helpers.js");
 // Finds import/require statements of a given path in an AST.
 const getImports = (node, importPath) => {
     const esmImports = getImportsFromESM(node, importPath);
@@ -19,7 +19,7 @@ const getImportsFromCJS = (node, importPath) => {
         return [];
     }
     const { declarations } = node;
-    const requireDeclaration = declarations.find((declaration) => declaration.type === 'VariableDeclarator' && (0, helpers_1.isRequire)(declaration.init, importPath));
+    const requireDeclaration = declarations.find((declaration) => declaration.type === 'VariableDeclarator' && (0, helpers_js_1.isRequire)(declaration.init, importPath));
     if (requireDeclaration === undefined || requireDeclaration.id.type !== 'ObjectPattern') {
         return [];
     }
@@ -34,12 +34,12 @@ const getImportsFromCJS = (node, importPath) => {
         }
         return { imported: key.name, local: value.name };
     })
-        .filter(non_nullable_1.nonNullable);
+        .filter(non_nullable_js_1.nonNullable);
     return imports;
 };
 // Finds import/require statements of a given path in an ESM AST.
 const getImportsFromESM = (node, importPath) => {
-    if (!(0, helpers_1.isImport)(node, importPath)) {
+    if (!(0, helpers_js_1.isImport)(node, importPath)) {
         return [];
     }
     const { specifiers } = node;
@@ -54,7 +54,7 @@ const getImportsFromESM = (node, importPath) => {
         }
         return { imported: imported.name, local: local.name };
     })
-        .filter(non_nullable_1.nonNullable);
+        .filter(non_nullable_js_1.nonNullable);
     return imports;
 };
 //# sourceMappingURL=imports.js.map

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

@@ -5,7 +5,7 @@ exports.safelyParseFile = exports.parseExpression = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const parser_1 = require("@babel/parser");
-const non_nullable_1 = require("../../../utils/non_nullable");
+const non_nullable_js_1 = require("../../../utils/non_nullable.js");
 const GLOB_WILDCARD = '**';
 // Transforms an array of glob nodes into a glob string including an absolute
 // path.
@@ -159,7 +159,7 @@ const parseTemplateLiteral = (expression) => {
                 return getWildcardFromASTNode(part);
         }
     });
-    return globNodes.filter(non_nullable_1.nonNullable);
+    return globNodes.filter(non_nullable_js_1.nonNullable);
 };
 // For our purposes, we consider a glob to be valid if all the nodes are
 // strings and the first node is static (i.e. not a wildcard character).

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

@@ -1,2 +1,2 @@
-import { PackageJson } from './package_json';
+import { PackageJson } from './package_json.js';
 export declare const isNativeModule: ({ binary, dependencies, devDependencies, files, gypfile, }: PackageJson) => boolean;

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

@@ -1,4 +1,4 @@
-import type { ModuleFormat } from './module_format';
+import type { ModuleFormat } from './module_format.js';
 export interface EntryFile {
     contents: string;
     filename: string;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEntryFile = void 0;
 const path_1 = require("path");
-const normalize_path_1 = require("./normalize_path");
+const normalize_path_js_1 = require("./normalize_path.js");
 const getEntryFileContents = (mainPath, moduleFormat) => {
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
     if (moduleFormat === 'cjs') {
@@ -11,7 +11,7 @@ const getEntryFileContents = (mainPath, moduleFormat) => {
     return `export { handler } from '${importPath}'`;
 };
 const getEntryFile = ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }) => {
-    const mainPath = (0, normalize_path_1.normalizeFilePath)({ commonPrefix, path: mainFile, userNamespace });
+    const mainPath = (0, normalize_path_js_1.normalizeFilePath)({ commonPrefix, path: mainFile, userNamespace });
     const extension = (0, path_1.extname)(filename);
     const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
     const contents = getEntryFileContents(mainPath, moduleFormat);

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

@@ -1,4 +1,4 @@
-import type { ModuleFormat } from './module_format';
+import type { ModuleFormat } from './module_format.js';
 export declare type ArchiveFormat = 'none' | 'zip';
 interface ZipNodeParameters {
     aliases?: Map<string, string>;

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

@@ -11,17 +11,17 @@ const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
 const del_1 = __importDefault(require("del"));
 const p_map_1 = __importDefault(require("p-map"));
-const archive_1 = require("../../../archive");
-const fs_2 = require("../../../utils/fs");
-const entry_file_1 = require("./entry_file");
-const normalize_path_1 = require("./normalize_path");
+const archive_js_1 = require("../../../archive.js");
+const fs_js_1 = require("../../../utils/fs.js");
+const entry_file_js_1 = require("./entry_file.js");
+const normalize_path_js_1 = require("./normalize_path.js");
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os_1.default.cpus().length === 0 ? 2 : os_1.default.cpus().length * 2;
 // Sub-directory to place all user-defined files  (i.e. everything other than
 // the entry file generated by zip-it-and-ship-it).
 const DEFAULT_USER_SUBDIRECTORY = 'src';
 const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, moduleFormat, rewrites = new Map(), srcFiles, }) {
-    const { contents: entryContents, filename: entryFilename } = (0, entry_file_1.getEntryFile)({
+    const { contents: entryContents, filename: entryFilename } = (0, entry_file_js_1.getEntryFile)({
         commonPrefix: basePath,
         filename,
         mainFile,
@@ -37,14 +37,14 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
     // Copying source files.
     await (0, p_map_1.default)(srcFiles, (srcFile) => {
         const destPath = aliases.get(srcFile) || srcFile;
-        const normalizedDestPath = (0, normalize_path_1.normalizeFilePath)({
+        const normalizedDestPath = (0, normalize_path_js_1.normalizeFilePath)({
             commonPrefix: basePath,
             path: destPath,
             userNamespace: DEFAULT_USER_SUBDIRECTORY,
         });
         const absoluteDestPath = (0, path_1.join)(functionFolder, normalizedDestPath);
         if (rewrites.has(srcFile)) {
-            return (0, fs_2.mkdirAndWriteFile)(absoluteDestPath, rewrites.get(srcFile));
+            return (0, fs_js_1.mkdirAndWriteFile)(absoluteDestPath, rewrites.get(srcFile));
         }
         return (0, cp_file_1.default)(srcFile, absoluteDestPath);
     }, { concurrency: COPY_FILE_CONCURRENCY });
@@ -52,7 +52,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
 };
 const createZipArchive = async function ({ aliases, basePath, destFolder, extension, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
     const destPath = (0, path_1.join)(destFolder, `${(0, path_1.basename)(filename, extension)}.zip`);
-    const { archive, output } = (0, archive_1.startZip)(destPath);
+    const { archive, output } = (0, archive_js_1.startZip)(destPath);
     const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
     const entryFilePath = (0, path_1.resolve)(basePath, entryFilename);
     // We don't need an entry file if it would end up with the same path as the
@@ -66,7 +66,7 @@ const createZipArchive = async function ({ aliases, basePath, destFolder, extens
     // than the entry file) to its own sub-directory.
     const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : '';
     if (needsEntryFile) {
-        const entryFile = (0, entry_file_1.getEntryFile)({ commonPrefix: basePath, filename, mainFile, moduleFormat, userNamespace });
+        const entryFile = (0, entry_file_js_1.getEntryFile)({ commonPrefix: basePath, filename, mainFile, moduleFormat, userNamespace });
         addEntryFileToZip(archive, entryFile);
     }
     const srcFilesInfos = await Promise.all(srcFiles.map(addStat));
@@ -83,7 +83,7 @@ const createZipArchive = async function ({ aliases, basePath, destFolder, extens
             userNamespace,
         });
     });
-    await (0, archive_1.endZip)(archive, output);
+    await (0, archive_js_1.endZip)(archive, output);
     return destPath;
 };
 const zipNodeJs = function ({ archiveFormat, ...options }) {
@@ -95,7 +95,7 @@ const zipNodeJs = function ({ archiveFormat, ...options }) {
 exports.zipNodeJs = zipNodeJs;
 const addEntryFileToZip = function (archive, { contents, filename }) {
     const contentBuffer = buffer_1.Buffer.from(contents);
-    (0, archive_1.addZipContent)(archive, contentBuffer, filename);
+    (0, archive_js_1.addZipContent)(archive, contentBuffer, filename);
 };
 const addStat = async function (srcFile) {
     const stat = await fs_1.promises.lstat(srcFile);
@@ -103,12 +103,12 @@ const addStat = async function (srcFile) {
 };
 const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrites = new Map(), stat, srcFile, userNamespace, }) {
     const destPath = aliases.get(srcFile) || srcFile;
-    const normalizedDestPath = (0, normalize_path_1.normalizeFilePath)({ commonPrefix, path: destPath, userNamespace });
+    const normalizedDestPath = (0, normalize_path_js_1.normalizeFilePath)({ commonPrefix, path: destPath, userNamespace });
     if (rewrites.has(srcFile)) {
-        (0, archive_1.addZipContent)(archive, rewrites.get(srcFile), normalizedDestPath);
+        (0, archive_js_1.addZipContent)(archive, rewrites.get(srcFile), normalizedDestPath);
     }
     else {
-        (0, archive_1.addZipFile)(archive, srcFile, normalizedDestPath, stat);
+        (0, archive_js_1.addZipFile)(archive, srcFile, normalizedDestPath, stat);
     }
 };
 //# sourceMappingURL=zip.js.map

package/dist/runtimes/runtime.d.ts

@@ -1,10 +1,10 @@
-import { ArchiveFormat } from '../archive';
-import { FunctionConfig } from '../config';
-import { FeatureFlags } from '../feature_flags';
-import { FunctionSource, SourceFile } from '../function';
-import { FsCache } from '../utils/fs';
-import type { NodeBundlerName } from './node/bundlers';
-import type { ISCValues } from './node/in_source_config';
+import { ArchiveFormat } from '../archive.js';
+import { FunctionConfig } from '../config.js';
+import { FeatureFlags } from '../feature_flags.js';
+import { FunctionSource, SourceFile } from '../function.js';
+import { FsCache } from '../utils/fs.js';
+import type { NodeBundlerName } from './node/bundlers/index.js';
+import type { ISCValues } from './node/in_source_config/index.js';
 export declare type RuntimeName = 'go' | 'js' | 'rs';
 export declare type FindFunctionsInPathsFunction = (args: {
     featureFlags: FeatureFlags;

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { FunctionConfig } from '../../config';
+import { FunctionConfig } from '../../config.js';
 export declare const build: ({ config, name, srcDir }: {
     config: FunctionConfig;
     name: string;

package/dist/runtimes/rust/builder.js

@@ -8,8 +8,8 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const tmp_promise_1 = __importDefault(require("tmp-promise"));
 const toml_1 = __importDefault(require("toml"));
-const shell_1 = require("../../utils/shell");
-const constants_1 = require("./constants");
+const shell_js_1 = require("../../utils/shell.js");
+const constants_js_1 = require("./constants.js");
 const runtimeName = 'rs';
 const build = async ({ config, name, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
@@ -26,9 +26,9 @@ const build = async ({ config, name, srcDir }) => {
     // way to override it (https://github.com/rust-lang/cargo/issues/1706). We
     // must extract the crate name from the manifest and use it to form the path
     // to the binary.
-    const manifest = await fs_1.promises.readFile((0, path_1.join)(srcDir, constants_1.MANIFEST_NAME), 'utf8');
+    const manifest = await fs_1.promises.readFile((0, path_1.join)(srcDir, constants_js_1.MANIFEST_NAME), 'utf8');
     const { package: { name: packageName }, } = toml_1.default.parse(manifest);
-    const binaryPath = (0, path_1.join)(targetDirectory, constants_1.BUILD_TARGET, 'release', packageName);
+    const binaryPath = (0, path_1.join)(targetDirectory, constants_js_1.BUILD_TARGET, 'release', packageName);
     const stat = await fs_1.promises.lstat(binaryPath);
     return {
         path: binaryPath,
@@ -38,7 +38,7 @@ const build = async ({ config, name, srcDir }) => {
 exports.build = build;
 const cargoBuild = async ({ functionName, srcDir, targetDirectory, }) => {
     try {
-        await shell_1.shellUtils.runCommand('cargo', ['build', '--target', constants_1.BUILD_TARGET, '--release'], {
+        await shell_js_1.shellUtils.runCommand('cargo', ['build', '--target', constants_js_1.BUILD_TARGET, '--release'], {
             cwd: srcDir,
             env: {
                 CARGO_TARGET_DIR: targetDirectory,
@@ -60,7 +60,7 @@ const cargoBuild = async ({ functionName, srcDir, targetDirectory, }) => {
 };
 const checkRustToolchain = async () => {
     try {
-        await shell_1.shellUtils.runCommand('cargo', ['-V']);
+        await shell_js_1.shellUtils.runCommand('cargo', ['-V']);
         return true;
     }
     catch {
@@ -86,8 +86,8 @@ let toolchainInstallation;
 // `BUILD_TARGET`. The Promise is saved to `toolchainInstallation`, so
 // that we run the command just once for multiple Rust functions.
 const installToolchain = async () => {
-    await shell_1.shellUtils.runCommand('rustup', ['default', 'stable']);
-    await shell_1.shellUtils.runCommand('rustup', ['target', 'add', constants_1.BUILD_TARGET]);
+    await shell_js_1.shellUtils.runCommand('rustup', ['default', 'stable']);
+    await shell_js_1.shellUtils.runCommand('rustup', ['target', 'add', constants_js_1.BUILD_TARGET]);
 };
 const installToolchainOnce = () => {
     if (toolchainInstallation === undefined) {

package/dist/runtimes/rust/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/rust/index.js

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
-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 constants_1 = require("./constants");
+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 constants_js_1 = require("./constants.js");
 const detectRustFunction = 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;
     }
     // @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 hasCargoManifest = files.includes(constants_1.MANIFEST_NAME);
+    const files = (await (0, fs_js_1.cachedReaddir)(fsCache, path));
+    const hasCargoManifest = files.includes(constants_js_1.MANIFEST_NAME);
     if (!hasCargoManifest) {
         return;
     }
     const mainFilePath = (0, path_1.join)(path, 'src', 'main.rs');
     try {
-        const mainFile = await (0, fs_1.cachedLstat)(fsCache, mainFilePath);
+        const mainFile = await (0, fs_js_1.cachedLstat)(fsCache, mainFilePath);
         if (mainFile.isFile()) {
             return mainFilePath;
         }
@@ -32,10 +32,10 @@ const detectRustFunction = async ({ fsCache, path }) => {
 };
 const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths, }) {
     const functions = await Promise.all(paths.map((path) => findFunctionInPath({ path, featureFlags, fsCache })));
-    return functions.filter(non_nullable_1.nonNullable);
+    return functions.filter(non_nullable_js_1.nonNullable);
 };
 const findFunctionInPath = async function ({ path, featureFlags, fsCache }) {
-    const runtime = await (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+    const runtime = await (0, detect_runtime_js_1.detectBinaryRuntime)({ fsCache, path });
     if (runtime === 'rs') {
         return processBinary({ fsCache, path });
     }
@@ -48,7 +48,7 @@ const findFunctionInPath = async function ({ path, featureFlags, fsCache }) {
     }
 };
 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 filename = (0, path_1.basename)(path);
     const extension = (0, path_1.extname)(path);
     const name = (0, path_1.basename)(path, extension);
@@ -67,7 +67,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)(path);
     const name = (0, path_1.basename)(path, extension);
@@ -96,11 +96,11 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, ru
     // the resulting binary. Otherwise, we're dealing with a binary so we zip it
     // directly.
     if (isSource) {
-        const { path: binaryPath, stat: binaryStat } = await (0, builder_1.build)({ config, name: filename, srcDir });
-        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath: binaryPath, stat: binaryStat });
+        const { path: binaryPath, stat: binaryStat } = await (0, builder_js_1.build)({ config, name: filename, srcDir });
+        await (0, zip_binary_js_1.zipBinary)({ ...zipOptions, srcPath: binaryPath, stat: binaryStat });
     }
     else {
-        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath, stat });
+        await (0, zip_binary_js_1.zipBinary)({ ...zipOptions, srcPath, stat });
     }
     return { config, path: destPath };
 };

package/dist/utils/archive_size.d.ts

@@ -1,2 +1,2 @@
-import type { FunctionArchive } from '../function';
+import type { FunctionArchive } from '../function.js';
 export declare const addArchiveSize: (result: FunctionArchive) => Promise<FunctionArchive>;

package/dist/utils/format_result.d.ts

@@ -1,5 +1,5 @@
-import { FunctionArchive } from '../function';
-import { RuntimeName } from '../runtimes/runtime';
+import { FunctionArchive } from '../function.js';
+import { RuntimeName } from '../runtimes/runtime.js';
 export declare type FunctionResult = Omit<FunctionArchive, 'runtime'> & {
     runtime: RuntimeName;
     schedule?: string;

package/dist/utils/format_result.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatZipResult = void 0;
-const remove_undefined_1 = require("./remove_undefined");
+const remove_undefined_js_1 = require("./remove_undefined.js");
 // Takes the result of zipping a function and formats it for output.
 const formatZipResult = (archive) => {
     var _a, _b, _c;
@@ -11,7 +11,7 @@ const formatZipResult = (archive) => {
         runtime: archive.runtime.name,
         schedule: (_b = (_a = archive.inSourceConfig) === null || _a === void 0 ? void 0 : _a.schedule) !== null && _b !== void 0 ? _b : (_c = archive === null || archive === void 0 ? void 0 : archive.config) === null || _c === void 0 ? void 0 : _c.schedule,
     };
-    return (0, remove_undefined_1.removeUndefined)(functionResult);
+    return (0, remove_undefined_js_1.removeUndefined)(functionResult);
 };
 exports.formatZipResult = formatZipResult;
 //# sourceMappingURL=format_result.js.map

package/dist/utils/fs.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mkdirAndWriteFile = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.safeUnlink = exports.getPathWithExtension = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const non_nullable_1 = require("./non_nullable");
+const non_nullable_js_1 = require("./non_nullable.js");
 // This caches multiple FS calls to the same path. It creates a cache key with
 // the name of the function and the path (e.g. "readdir:/some/directory").
 //
@@ -43,7 +43,7 @@ const listFunctionsDirectories = async function (srcFolders) {
             return null;
         }
     }));
-    const validDirectories = filenamesByDirectory.filter(non_nullable_1.nonNullable);
+    const validDirectories = filenamesByDirectory.filter(non_nullable_js_1.nonNullable);
     if (validDirectories.length === 0) {
         throw new Error(`Functions folder does not exist: ${srcFolders.join(', ')}`);
     }

package/dist/zip.d.ts

@@ -1,6 +1,6 @@
-import { ArchiveFormat } from './archive';
-import { Config } from './config';
-import { FeatureFlags } from './feature_flags';
+import { ArchiveFormat } from './archive.js';
+import { Config } from './config.js';
+import { FeatureFlags } from './feature_flags.js';
 interface ZipFunctionOptions {
     archiveFormat?: ArchiveFormat;
     basePath?: string;
@@ -13,9 +13,9 @@ declare type ZipFunctionsOptions = ZipFunctionOptions & {
     manifest?: string;
     parallelLimit?: number;
 };
-export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function").FunctionArchive, "runtime"> & {
-    runtime: import("./runtimes/runtime").RuntimeName;
+export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
+    runtime: import("./runtimes/runtime.js").RuntimeName;
     schedule?: string | undefined;
 })[]>;
-export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result").FunctionResult | undefined>;
+export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
 export {};

package/dist/zip.js

@@ -7,13 +7,13 @@ exports.zipFunction = exports.zipFunctions = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const p_map_1 = __importDefault(require("p-map"));
-const feature_flags_1 = require("./feature_flags");
-const manifest_1 = require("./manifest");
-const runtimes_1 = require("./runtimes");
-const archive_size_1 = require("./utils/archive_size");
-const format_result_1 = require("./utils/format_result");
-const fs_2 = require("./utils/fs");
-const non_nullable_1 = require("./utils/non_nullable");
+const feature_flags_js_1 = require("./feature_flags.js");
+const manifest_js_1 = require("./manifest.js");
+const index_js_1 = require("./runtimes/index.js");
+const archive_size_js_1 = require("./utils/archive_size.js");
+const format_result_js_1 = require("./utils/format_result.js");
+const fs_js_1 = require("./utils/fs.js");
+const non_nullable_js_1 = require("./utils/non_nullable.js");
 const DEFAULT_PARALLEL_LIMIT = 5;
 // TODO: now that we have types, do we still need runtime validation?
 const validateArchiveFormat = (archiveFormat) => {
@@ -25,10 +25,10 @@ const validateArchiveFormat = (archiveFormat) => {
 // used by AWS Lambda
 const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFormat = 'zip', basePath, config = {}, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, } = {}) {
     validateArchiveFormat(archiveFormat);
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_2.resolveFunctionsDirectories)(relativeSrcFolders);
-    const [paths] = await Promise.all([(0, fs_2.listFunctionsDirectories)(srcFolders), fs_1.promises.mkdir(destFolder, { recursive: true })]);
-    const functions = await (0, runtimes_1.getFunctionsFromPaths)(paths, { config, dedupe: true, featureFlags });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const [paths] = await Promise.all([(0, fs_js_1.listFunctionsDirectories)(srcFolders), fs_1.promises.mkdir(destFolder, { recursive: true })]);
+    const functions = await (0, index_js_1.getFunctionsFromPaths)(paths, { config, dedupe: true, featureFlags });
     const results = await (0, p_map_1.default)(functions.values(), async (func) => {
         const zipResult = await func.runtime.zipFunction({
             archiveFormat,
@@ -50,21 +50,21 @@ const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFo
     }, {
         concurrency: parallelLimit,
     });
-    const formattedResults = await Promise.all(results.filter(non_nullable_1.nonNullable).map(async (result) => {
-        const resultWithSize = await (0, archive_size_1.addArchiveSize)(result);
-        return (0, format_result_1.formatZipResult)(resultWithSize);
+    const formattedResults = await Promise.all(results.filter(non_nullable_js_1.nonNullable).map(async (result) => {
+        const resultWithSize = await (0, archive_size_js_1.addArchiveSize)(result);
+        return (0, format_result_js_1.formatZipResult)(resultWithSize);
     }));
     if (manifest !== undefined) {
-        await (0, manifest_1.createManifest)({ functions: formattedResults, path: (0, path_1.resolve)(manifest) });
+        await (0, manifest_js_1.createManifest)({ functions: formattedResults, path: (0, path_1.resolve)(manifest) });
     }
     return formattedResults;
 };
 exports.zipFunctions = zipFunctions;
 const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, } = {}) {
     validateArchiveFormat(archiveFormat);
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
     const srcPath = (0, path_1.resolve)(relativeSrcPath);
-    const functions = await (0, runtimes_1.getFunctionsFromPaths)([srcPath], { config: inputConfig, dedupe: true, featureFlags });
+    const functions = await (0, index_js_1.getFunctionsFromPaths)([srcPath], { config: inputConfig, dedupe: true, featureFlags });
     if (functions.size === 0) {
         return;
     }
@@ -86,7 +86,7 @@ const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat
         srcPath,
         stat: stats,
     });
-    return (0, format_result_1.formatZipResult)({ ...zipResult, mainFile, name, runtime });
+    return (0, format_result_js_1.formatZipResult)({ ...zipResult, mainFile, name, runtime });
 };
 exports.zipFunction = zipFunction;
 //# sourceMappingURL=zip.js.map

package/dist/zip_binary.d.ts

@@ -1,5 +1,5 @@
 import type { Stats } from 'fs';
-import { Runtime } from './runtimes/runtime';
+import { Runtime } from './runtimes/runtime.js';
 export declare const zipBinary: ({ destPath, filename, runtime, srcPath, stat, }: {
     destPath: string;
     filename: string;

package/dist/zip_binary.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zipBinary = void 0;
-const archive_1 = require("./archive");
+const archive_js_1 = require("./archive.js");
 // Zip a binary function file
 const zipBinary = async function ({ destPath, filename, runtime, srcPath, stat, }) {
-    const { archive, output } = (0, archive_1.startZip)(destPath);
-    (0, archive_1.addZipFile)(archive, srcPath, filename, stat);
-    (0, archive_1.addZipContent)(archive, JSON.stringify({ runtime: runtime.name }), 'netlify-toolchain');
-    await (0, archive_1.endZip)(archive, output);
+    const { archive, output } = (0, archive_js_1.startZip)(destPath);
+    (0, archive_js_1.addZipFile)(archive, srcPath, filename, stat);
+    (0, archive_js_1.addZipContent)(archive, JSON.stringify({ runtime: runtime.name }), 'netlify-toolchain');
+    await (0, archive_js_1.endZip)(archive, output);
 };
 exports.zipBinary = zipBinary;
 //# sourceMappingURL=zip_binary.js.map