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

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,4 +1,3 @@
 import { Statement } from '@babel/types';
-import type { ISCExport } from '../in_source_config';
-declare const getMainExport: (nodes: Statement[]) => ISCExport[];
-export { getMainExport };
+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/helpers.d.ts

@@ -1,7 +1,6 @@
 import { AssignmentExpression, Expression, ExpressionStatement, ImportDeclaration, Statement } from '@babel/types';
-declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
-declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
+export declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
+export declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
     expression: AssignmentExpression;
 };
-declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;
-export { isImport, isModuleExports, isRequire };
+export declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;

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

@@ -1,6 +1,5 @@
 import { Statement } from '@babel/types';
-declare const getImports: (node: Statement, importPath: string) => {
+export declare const getImports: (node: Statement, importPath: string) => {
     imported: string;
     local: string;
 }[];
-export { getImports };

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

@@ -1,4 +1,4 @@
-declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
+export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
     basePath: string;
     expression: string;
     resolveDir: string;
@@ -6,5 +6,4 @@ declare const parseExpression: ({ basePath, expression: rawExpression, resolveDi
     includedPathsGlob: string | null | undefined;
     type: string;
 } | undefined;
-declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;
-export { parseExpression, safelyParseFile };
+export declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;

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

@@ -1,2 +1 @@
-declare const getBasePath: (dirnames: string[]) => string;
-export { getBasePath };
+export declare const getBasePath: (dirnames: string[]) => string;

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

@@ -1,4 +1,3 @@
-declare const detectEsModule: ({ mainFile }: {
+export declare const detectEsModule: ({ mainFile }: {
     mainFile: string;
 }) => Promise<boolean>;
-export { detectEsModule };

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

@@ -1,3 +1,2 @@
-import { PackageJson } from './package_json';
-declare const isNativeModule: ({ binary, dependencies, devDependencies, files, gypfile, }: PackageJson) => boolean;
-export { isNativeModule };
+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,13 +1,12 @@
-import type { ModuleFormat } from './module_format';
-interface EntryFile {
+import type { ModuleFormat } from './module_format.js';
+export interface EntryFile {
     contents: string;
     filename: string;
 }
-declare const getEntryFile: ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }: {
+export declare const getEntryFile: ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }: {
     commonPrefix: string;
     filename: string;
     mainFile: string;
     moduleFormat: ModuleFormat;
     userNamespace: string;
 }) => EntryFile;
-export { EntryFile, getEntryFile };

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

@@ -1,6 +1,5 @@
-declare const filterExcludedPaths: (paths: string[], exclude?: string[]) => string[];
-declare const getPathsOfIncludedFiles: (includedFiles: string[], basePath?: string | undefined) => Promise<{
+export declare const filterExcludedPaths: (paths: string[], exclude?: string[]) => string[];
+export declare const getPathsOfIncludedFiles: (includedFiles: string[], basePath?: string | undefined) => Promise<{
     exclude: string[];
     paths: string[];
 }>;
-export { filterExcludedPaths, getPathsOfIncludedFiles };

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

@@ -1,2 +1 @@
-declare const getModuleName: (dependency: string) => string;
-export { getModuleName };
+export declare const getModuleName: (dependency: string) => string;

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

@@ -1,10 +1,10 @@
 declare type SupportedVersionNumbers = 8 | 10 | 12 | 14;
-declare type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
-interface NodeVersionSupport {
+export declare type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+export interface NodeVersionSupport {
     esm: boolean;
 }
-declare const DEFAULT_NODE_VERSION = 14;
-declare const getNodeVersion: (configVersion?: string | undefined) => number;
-declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
-declare const parseVersion: (input: string | undefined) => number | undefined;
-export { DEFAULT_NODE_VERSION, getNodeSupportMatrix, getNodeVersion, NodeVersionString, NodeVersionSupport, parseVersion, };
+export declare const DEFAULT_NODE_VERSION = 14;
+export declare const getNodeVersion: (configVersion?: string | undefined) => number;
+export declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
+export declare const parseVersion: (input: string | undefined) => number | undefined;
+export {};

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

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVersion = exports.getNodeVersion = exports.getNodeSupportMatrix = exports.DEFAULT_NODE_VERSION = void 0;
+exports.parseVersion = exports.getNodeSupportMatrix = exports.getNodeVersion = exports.DEFAULT_NODE_VERSION = void 0;
 // Must match the default version used in Bitballoon.
-const DEFAULT_NODE_VERSION = 14;
-exports.DEFAULT_NODE_VERSION = DEFAULT_NODE_VERSION;
+exports.DEFAULT_NODE_VERSION = 14;
 const VERSION_REGEX = /(nodejs)?(\d+)\.x/;
-const getNodeVersion = (configVersion) => { var _a; return (_a = parseVersion(configVersion)) !== null && _a !== void 0 ? _a : DEFAULT_NODE_VERSION; };
+const getNodeVersion = (configVersion) => { var _a; return (_a = (0, exports.parseVersion)(configVersion)) !== null && _a !== void 0 ? _a : exports.DEFAULT_NODE_VERSION; };
 exports.getNodeVersion = getNodeVersion;
 const getNodeSupportMatrix = (configVersion) => {
-    const versionNumber = getNodeVersion(configVersion);
+    const versionNumber = (0, exports.getNodeVersion)(configVersion);
     return {
         esm: versionNumber >= 14,
     };

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

@@ -1,6 +1,5 @@
-declare const normalizeFilePath: ({ commonPrefix, path, userNamespace, }: {
+export declare const normalizeFilePath: ({ commonPrefix, path, userNamespace, }: {
     commonPrefix: string;
     path: string;
     userNamespace: string;
 }) => string;
-export { normalizeFilePath };

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

@@ -1,4 +1,4 @@
-interface PackageJson {
+export interface PackageJson {
     name?: string;
     version?: string;
     dependencies?: Record<string, string>;
@@ -13,7 +13,11 @@ interface PackageJson {
     binary?: boolean;
     type?: string;
 }
-declare const sanitisePackageJson: (packageJson: Record<string, unknown>) => PackageJson;
-declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
-declare const getPackageJsonIfAvailable: (srcDir: string) => Promise<PackageJson>;
-export { getPackageJson, getPackageJsonIfAvailable, PackageJson, sanitisePackageJson };
+export interface PackageJsonFile {
+    contents: PackageJson;
+    path: string;
+}
+export declare const getClosestPackageJson: (resolveDir: string) => Promise<PackageJsonFile | null>;
+export declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
+export declare const getPackageJsonIfAvailable: (srcDir: string) => Promise<PackageJson>;
+export declare const sanitisePackageJson: (packageJson: Record<string, unknown>) => PackageJson;

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

@@ -3,40 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitisePackageJson = exports.getPackageJsonIfAvailable = exports.getPackageJson = void 0;
+exports.sanitisePackageJson = exports.getPackageJsonIfAvailable = exports.getPackageJson = exports.getClosestPackageJson = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const find_up_1 = __importDefault(require("find-up"));
 const pkg_dir_1 = __importDefault(require("pkg-dir"));
-const sanitiseFiles = (files) => {
-    if (!Array.isArray(files)) {
-        return undefined;
+const getClosestPackageJson = async (resolveDir) => {
+    const packageJsonPath = await (0, find_up_1.default)(async (directory) => {
+        // We stop traversing if we're about to leave the boundaries of any
+        // node_modules directory.
+        if ((0, path_1.basename)(directory) === 'node_modules') {
+            return find_up_1.default.stop;
+        }
+        const path = (0, path_1.join)(directory, 'package.json');
+        const hasPackageJson = await find_up_1.default.exists(path);
+        return hasPackageJson ? path : undefined;
+    }, { cwd: resolveDir });
+    if (packageJsonPath === undefined) {
+        return null;
     }
-    return files.filter((file) => typeof file === 'string');
+    const packageJson = await readPackageJson(packageJsonPath);
+    return {
+        contents: packageJson,
+        path: packageJsonPath,
+    };
 };
-const sanitisePackageJson = (packageJson) => ({
-    ...packageJson,
-    files: sanitiseFiles(packageJson.files),
-});
-exports.sanitisePackageJson = sanitisePackageJson;
+exports.getClosestPackageJson = getClosestPackageJson;
 // Retrieve the `package.json` of a specific project or module
 const getPackageJson = async function (srcDir) {
     const packageRoot = await (0, pkg_dir_1.default)(srcDir);
     if (packageRoot === undefined) {
         return {};
     }
-    const packageJsonPath = `${packageRoot}/package.json`;
-    try {
-        // The path depends on the user's build, i.e. must be dynamic
-        // eslint-disable-next-line import/no-dynamic-require, node/global-require, @typescript-eslint/no-var-requires
-        const packageJson = require(packageJsonPath);
-        return sanitisePackageJson(packageJson);
-    }
-    catch (error) {
-        throw new Error(`${packageJsonPath} is invalid JSON: ${error.message}`);
-    }
+    return readPackageJson(`${packageRoot}/package.json`);
 };
 exports.getPackageJson = getPackageJson;
 const getPackageJsonIfAvailable = async (srcDir) => {
     try {
-        const packageJson = await getPackageJson(srcDir);
+        const packageJson = await (0, exports.getPackageJson)(srcDir);
         return packageJson;
     }
     catch {
@@ -44,4 +48,25 @@ const getPackageJsonIfAvailable = async (srcDir) => {
     }
 };
 exports.getPackageJsonIfAvailable = getPackageJsonIfAvailable;
+const readPackageJson = async (path) => {
+    try {
+        // The path depends on the user's build, i.e. must be dynamic
+        const packageJson = JSON.parse(await fs_1.promises.readFile(path, 'utf8'));
+        return (0, exports.sanitisePackageJson)(packageJson);
+    }
+    catch (error) {
+        throw new Error(`${path} is invalid JSON: ${error.message}`);
+    }
+};
+const sanitiseFiles = (files) => {
+    if (!Array.isArray(files)) {
+        return undefined;
+    }
+    return files.filter((file) => typeof file === 'string');
+};
+const sanitisePackageJson = (packageJson) => ({
+    ...packageJson,
+    files: sanitiseFiles(packageJson.files),
+});
+exports.sanitisePackageJson = sanitisePackageJson;
 //# sourceMappingURL=package_json.js.map

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

@@ -1,3 +1,2 @@
-declare const createAliases: (paths: string[], pluginsModulesPath: string | undefined, aliases: Map<string, string>, basePath: string) => void;
-declare const getPluginsModulesPath: (srcDir: string) => Promise<string | undefined>;
-export { createAliases, getPluginsModulesPath };
+export declare const createAliases: (paths: string[], pluginsModulesPath: string | undefined, aliases: Map<string, string>, basePath: string) => void;
+export declare const getPluginsModulesPath: (srcDir: string) => Promise<string | undefined>;

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

@@ -1,7 +1,6 @@
-interface TraversalCache {
+export interface TraversalCache {
     localFiles: Set<string>;
     moduleNames: Set<string>;
     modulePaths: Set<string>;
 }
-declare const getNewCache: () => TraversalCache;
-export { TraversalCache, getNewCache };
+export declare const getNewCache: () => TraversalCache;

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

@@ -1,5 +1,5 @@
-import type { ModuleFormat } from './module_format';
-declare type ArchiveFormat = 'none' | 'zip';
+import type { ModuleFormat } from './module_format.js';
+export declare type ArchiveFormat = 'none' | 'zip';
 interface ZipNodeParameters {
     aliases?: Map<string, string>;
     basePath: string;
@@ -11,7 +11,7 @@ interface ZipNodeParameters {
     rewrites?: Map<string, string>;
     srcFiles: string[];
 }
-declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {
+export declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {
     archiveFormat: ArchiveFormat;
 }) => Promise<string>;
-export { ArchiveFormat, zipNodeJs };
+export {};

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,28 +1,28 @@
-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';
-declare type RuntimeName = 'go' | 'js' | 'rs';
-declare type FindFunctionsInPathsFunction = (args: {
+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;
     fsCache: FsCache;
     paths: string[];
 }) => Promise<SourceFile[]>;
-declare type FindFunctionInPathFunction = (args: {
+export declare type FindFunctionInPathFunction = (args: {
     featureFlags: FeatureFlags;
     fsCache: FsCache;
     path: string;
 }) => Promise<SourceFile | undefined>;
-declare type GetSrcFilesFunction = (args: {
+export declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: FeatureFlags;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<string[]>;
-interface ZipFunctionResult {
+export interface ZipFunctionResult {
     bundler?: NodeBundlerName;
     bundlerErrors?: object[];
     bundlerWarnings?: object[];
@@ -33,7 +33,7 @@ interface ZipFunctionResult {
     nodeModulesWithDynamicImports?: string[];
     path: string;
 }
-declare type ZipFunction = (args: {
+export declare type ZipFunction = (args: {
     archiveFormat: ArchiveFormat;
     basePath?: string;
     config: FunctionConfig;
@@ -41,11 +41,10 @@ declare type ZipFunction = (args: {
     featureFlags: FeatureFlags;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<ZipFunctionResult>;
-interface Runtime {
+export interface Runtime {
     findFunctionsInPaths: FindFunctionsInPathsFunction;
     findFunctionInPath: FindFunctionInPathFunction;
     getSrcFiles?: GetSrcFilesFunction;
     name: RuntimeName;
     zipFunction: ZipFunction;
 }
-export { FindFunctionInPathFunction, FindFunctionsInPathsFunction, GetSrcFilesFunction, Runtime, RuntimeName, ZipFunction, ZipFunctionResult, };

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { FunctionConfig } from '../../config';
-declare const build: ({ config, name, srcDir }: {
+import { FunctionConfig } from '../../config.js';
+export declare const build: ({ config, name, srcDir }: {
     config: FunctionConfig;
     name: string;
     srcDir: string;
@@ -8,4 +8,3 @@ declare const build: ({ config, name, srcDir }: {
     path: string;
     stat: import("fs").Stats;
 }>;
-export { build };