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

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

@@ -1,6 +1,5 @@
-interface CargoManifest {
+export interface CargoManifest {
     package: {
         name: string;
     };
 }
-export { CargoManifest };

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

@@ -1,3 +1,2 @@
-declare const BUILD_TARGET = "x86_64-unknown-linux-musl";
-declare const MANIFEST_NAME = "Cargo.toml";
-export { BUILD_TARGET, MANIFEST_NAME };
+export declare const BUILD_TARGET = "x86_64-unknown-linux-musl";
+export declare const MANIFEST_NAME = "Cargo.toml";

package/dist/runtimes/rust/constants.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MANIFEST_NAME = exports.BUILD_TARGET = void 0;
-const BUILD_TARGET = 'x86_64-unknown-linux-musl';
-exports.BUILD_TARGET = BUILD_TARGET;
-const MANIFEST_NAME = 'Cargo.toml';
-exports.MANIFEST_NAME = MANIFEST_NAME;
+exports.BUILD_TARGET = 'x86_64-unknown-linux-musl';
+exports.MANIFEST_NAME = 'Cargo.toml';
 //# sourceMappingURL=constants.js.map

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

package/dist/utils/format_result.d.ts

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

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

@@ -1,18 +1,16 @@
 /// <reference types="node" />
 import { promises as fs } from 'fs';
-declare type FsCache = Record<string, unknown>;
-declare const cachedLstat: (cache: FsCache, path: string, opts?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
-declare const cachedReaddir: (cache: FsCache, path: string, options: import("fs").ObjectEncodingOptions & {
+export declare type FsCache = Record<string, unknown>;
+export declare const cachedLstat: (cache: FsCache, path: string, opts?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
+export declare const cachedReaddir: (cache: FsCache, path: string, options: import("fs").ObjectEncodingOptions & {
     withFileTypes: true;
 }) => Promise<import("fs").Dirent[]>;
-declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & import("events").Abortable & {
+export declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & import("events").Abortable & {
     flag?: import("fs").OpenMode | undefined;
 }) | null | undefined) => Promise<string | Buffer>;
-declare const getPathWithExtension: (path: string, extension: string) => string;
-declare const safeUnlink: (path: string) => Promise<void>;
-declare const listFunctionsDirectories: (srcFolders: string[]) => Promise<string[]>;
-declare const listFunctionsDirectory: (srcFolder: string) => Promise<string[]>;
-declare const resolveFunctionsDirectories: (input: string | string[]) => string[];
-declare const mkdirAndWriteFile: typeof fs.writeFile;
-export { cachedLstat, cachedReaddir, cachedReadFile, getPathWithExtension, listFunctionsDirectories, listFunctionsDirectory, resolveFunctionsDirectories, safeUnlink, mkdirAndWriteFile, };
-export type { FsCache };
+export declare const getPathWithExtension: (path: string, extension: string) => string;
+export declare const safeUnlink: (path: string) => Promise<void>;
+export declare const listFunctionsDirectories: (srcFolders: string[]) => Promise<string[]>;
+export declare const listFunctionsDirectory: (srcFolder: string) => Promise<string[]>;
+export declare const resolveFunctionsDirectories: (input: string | string[]) => string[];
+export declare const mkdirAndWriteFile: typeof fs.writeFile;

package/dist/utils/fs.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkdirAndWriteFile = exports.safeUnlink = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.getPathWithExtension = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
+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").
 //
@@ -18,12 +18,9 @@ const makeCachedFunction = (func) => (cache, path, ...args) => {
     }
     return cache[key];
 };
-const cachedLstat = makeCachedFunction(fs_1.promises.lstat);
-exports.cachedLstat = cachedLstat;
-const cachedReaddir = makeCachedFunction(fs_1.promises.readdir);
-exports.cachedReaddir = cachedReaddir;
-const cachedReadFile = makeCachedFunction(fs_1.promises.readFile);
-exports.cachedReadFile = cachedReadFile;
+exports.cachedLstat = makeCachedFunction(fs_1.promises.lstat);
+exports.cachedReaddir = makeCachedFunction(fs_1.promises.readdir);
+exports.cachedReadFile = makeCachedFunction(fs_1.promises.readFile);
 const getPathWithExtension = (path, extension) => (0, path_1.format)({ ...(0, path_1.parse)(path), base: undefined, ext: extension });
 exports.getPathWithExtension = getPathWithExtension;
 const safeUnlink = async (path) => {
@@ -39,14 +36,14 @@ exports.safeUnlink = safeUnlink;
 const listFunctionsDirectories = async function (srcFolders) {
     const filenamesByDirectory = await Promise.all(srcFolders.map(async (srcFolder) => {
         try {
-            const filenames = await listFunctionsDirectory(srcFolder);
+            const filenames = await (0, exports.listFunctionsDirectory)(srcFolder);
             return filenames;
         }
         catch {
             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/utils/non_nullable.d.ts

@@ -1,2 +1 @@
-declare const nonNullable: <T>(value: T) => value is NonNullable<T>;
-export { nonNullable };
+export declare const nonNullable: <T>(value: T) => value is NonNullable<T>;

package/dist/utils/remove_undefined.d.ts

@@ -1,2 +1 @@
-declare const removeUndefined: <T>(obj: T) => T;
-export { removeUndefined };
+export declare const removeUndefined: <T>(obj: T) => T;

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;
 };
-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;
 })[]>;
-declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result").FunctionResult | undefined>;
-export { zipFunction, zipFunctions };
+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

@@ -3,17 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zipFunctions = exports.zipFunction = void 0;
+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,10 +1,9 @@
 import type { Stats } from 'fs';
-import { Runtime } from './runtimes/runtime';
-declare const zipBinary: ({ destPath, filename, runtime, srcPath, stat, }: {
+import { Runtime } from './runtimes/runtime.js';
+export declare const zipBinary: ({ destPath, filename, runtime, srcPath, stat, }: {
     destPath: string;
     filename: string;
     runtime: Runtime;
     srcPath: string;
     stat: Stats;
 }) => Promise<void>;
-export { zipBinary };

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.7.2",
+  "version": "5.8.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -70,7 +70,7 @@
     "junk": "^3.1.0",
     "locate-path": "^6.0.0",
     "merge-options": "^3.0.4",
-    "minimatch": "^3.0.4",
+    "minimatch": "^4.0.0",
     "p-map": "^4.0.0",
     "path-exists": "^4.0.0",
     "pkg-dir": "^5.0.0",
@@ -81,7 +81,6 @@
     "semver": "^7.0.0",
     "tmp-promise": "^3.0.2",
     "toml": "^3.0.0",
-    "typescript": "^4.6.0-beta",
     "unixify": "^1.0.0",
     "yargs": "^16.0.0"
   },
@@ -105,7 +104,8 @@
     "sinon": "^13.0.0",
     "sort-on": "^4.1.1",
     "source-map-support": "^0.5.20",
-    "throat": "^6.0.1"
+    "throat": "^6.0.1",
+    "typescript": "^4.6.0-beta"
   },
   "engines": {
     "node": "^12.20.0 || ^14.14.0 || >=16.0.0"