@netlify/zip-it-and-ship-it 4.28.2 → 4.29.2

package/dist/archive.d.ts

@@ -11,4 +11,5 @@ declare const addZipFile: (archive: Archiver, file: string, name: string, stat:
 declare const addZipContent: (archive: Archiver, content: Buffer | string, name: string) => void;
 declare const endZip: (archive: Archiver, output: Writable) => Promise<void>;
 export { startZip, addZipFile, addZipContent, endZip };
-export type { ArchiveFormat, Archiver as ZipArchive };
+export type { ArchiveFormat };
+export { Archiver as ZipArchive } from 'archiver';

package/dist/feature_flags.js

@@ -6,6 +6,7 @@ const FLAGS = {
     buildGoSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
     buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
     defaultEsModulesToEsbuild: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
+    nftTranspile: false,
     parseWithEsbuild: false,
     traceWithNft: false,
 };

package/dist/main.d.ts

@@ -2,7 +2,6 @@ import './utils/polyfills';
 import { Config } from './config';
 import { FeatureFlags } from './feature_flags';
 import { RuntimeName } from './runtimes/runtime';
-import { zipFunction, zipFunctions } from './zip';
 interface ListedFunction {
     name: string;
     mainFile: string;
@@ -16,10 +15,10 @@ interface ListFunctionsOptions {
     basePath?: string;
     config?: Config;
     featureFlags?: FeatureFlags;
-    pluginsModulesPath?: string;
 }
 declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags }?: {
     featureFlags?: FeatureFlags;
 }) => Promise<ListedFunction[]>;
 declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
-export { zipFunctions, zipFunction, listFunctions, listFunctionsFiles };
+export { listFunctions, listFunctionsFiles };
+export { zipFunction, zipFunctions } from './zip';

package/dist/main.js

@@ -20,16 +20,12 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFunctionsFiles = exports.listFunctions = exports.zipFunction = exports.zipFunctions = void 0;
+exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunctions = void 0;
 const path_1 = require("path");
 require("./utils/polyfills");
 const feature_flags_1 = require("./feature_flags");
 const runtimes_1 = require("./runtimes");
-const plugin_modules_path_1 = require("./runtimes/node/utils/plugin_modules_path");
 const fs_1 = require("./utils/fs");
-const zip_1 = require("./zip");
-Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_1.zipFunction; } });
-Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_1.zipFunctions; } });
 // List all Netlify Functions main entry files for a specific directory
 const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -48,11 +44,8 @@ const listFunctionsFiles = function (relativeSrcFolders, { basePath, config, fea
         const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
         const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
         const paths = yield (0, fs_1.listFunctionsDirectories)(srcFolders);
-        const [functions, pluginsModulesPath] = yield Promise.all([
-            (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags }),
-            (0, plugin_modules_path_1.getPluginsModulesPath)(srcFolders[0]),
-        ]);
-        const listedFunctionsFiles = yield Promise.all([...functions.values()].map((func) => getListedFunctionFiles(func, { basePath, featureFlags, pluginsModulesPath })));
+        const functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
+        const listedFunctionsFiles = yield Promise.all([...functions.values()].map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
         return listedFunctionsFiles.flat();
     });
 };
@@ -79,4 +72,7 @@ const getSrcFiles = function (_a) {
             srcPath }, args));
     });
 };
+var zip_1 = require("./zip");
+Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_1.zipFunction; } });
+Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_1.zipFunctions; } });
 //# sourceMappingURL=main.js.map

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

@@ -1,6 +1,6 @@
 import type { BundleFunction } from '..';
 declare const bundler: {
     bundle: BundleFunction;
-    getSrcFiles: import("../../../runtime").GetSrcFilesFunction;
+    getSrcFiles: import("..").GetSrcFilesFunction;
 };
 export default bundler;

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

@@ -1,3 +1,3 @@
-import type { GetSrcFilesFunction } from '../../../runtime';
+import type { GetSrcFilesFunction } from '..';
 declare const getSrcFiles: GetSrcFilesFunction;
 export { getSrcFiles };

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

@@ -1,9 +1,8 @@
 import type { Message } from '@netlify/esbuild';
 import type { NodeBundlerName } from '..';
 import { FunctionConfig } from '../../../config';
-import { FeatureFlag } from '../../../feature_flags';
+import { FeatureFlag, FeatureFlags } from '../../../feature_flags';
 import { FunctionSource } from '../../../function';
-import { GetSrcFilesFunction } from '../../runtime';
 declare type BundlerWarning = Message;
 declare type CleanupFunction = () => Promise<void>;
 declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
@@ -25,6 +24,13 @@ declare type BundleFunction = (args: {
     nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
 }>;
+declare type GetSrcFilesFunction = (args: {
+    basePath?: string;
+    config: FunctionConfig;
+    featureFlags: FeatureFlags;
+    pluginsModulesPath?: string;
+    repositoryRoot?: string;
+} & FunctionSource) => Promise<string[]>;
 interface NodeBundler {
     bundle: BundleFunction;
     getSrcFiles: GetSrcFilesFunction;

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

@@ -1,4 +1,11 @@
 import { NodeFileTraceReasons } from '@vercel/nft';
+import type { FunctionConfig } from '../../../../config';
 import { FsCache } from '../../../../utils/fs';
-declare const getPatchedESMPackages: (esmPaths: Set<string>, reasons: NodeFileTraceReasons, fsCache: FsCache, basePath?: string | undefined) => Promise<Map<any, any>>;
-export { getPatchedESMPackages };
+declare const transpileESM: ({ basePath, config, esmPaths, fsCache, reasons, }: {
+    basePath: string | undefined;
+    config: FunctionConfig;
+    esmPaths: Set<string>;
+    fsCache: FsCache;
+    reasons: NodeFileTraceReasons;
+}) => Promise<Map<string, string>>;
+export { transpileESM };

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

@@ -9,23 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPatchedESMPackages = void 0;
+exports.transpileESM = void 0;
 const path_1 = require("path");
 const fs_1 = require("../../../../utils/fs");
-const getESMPackageJsons = (esmPaths, reasons, basePath) => {
-    const packageJsons = [...reasons.entries()]
-        .filter(([, reason]) => {
-        if (reason.type !== 'resolve') {
-            return false;
-        }
-        const hasESMParent = [...reason.parents].some((parentPath) => esmPaths.has(parentPath));
-        return hasESMParent;
-    })
-        .map(([path]) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
-    return packageJsons;
-};
-const getPatchedESMPackages = (esmPaths, reasons, fsCache, basePath) => __awaiter(void 0, void 0, void 0, function* () {
-    const packages = getESMPackageJsons(esmPaths, reasons, basePath);
+const transpile_1 = require("./transpile");
+const getPatchedESMPackages = (packages, fsCache) => __awaiter(void 0, void 0, void 0, function* () {
     const patchedPackages = yield Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
     const patchedPackagesMap = new Map();
     packages.forEach((packagePath, index) => {
@@ -33,11 +21,55 @@ const getPatchedESMPackages = (esmPaths, reasons, fsCache, basePath) => __awaite
     });
     return patchedPackagesMap;
 });
-exports.getPatchedESMPackages = getPatchedESMPackages;
 const patchESMPackage = (path, fsCache) => __awaiter(void 0, void 0, void 0, function* () {
     const file = (yield (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
     const packageJson = JSON.parse(file);
     const patchedPackageJson = Object.assign(Object.assign({}, packageJson), { type: 'commonjs' });
     return JSON.stringify(patchedPackageJson);
 });
+const shouldTranspile = (path, cache, reasons) => {
+    if (cache.has(path)) {
+        return cache.get(path);
+    }
+    const reason = reasons.get(path);
+    // This isn't an expected case, but if the path doesn't exist in `reasons` we
+    // don't transpile it.
+    if (reason === undefined) {
+        cache.set(path, false);
+        return false;
+    }
+    const { parents } = reason;
+    // If the path doesn't have any parents, it's safe to transpile.
+    if (parents.size === 0) {
+        cache.set(path, true);
+        return true;
+    }
+    // The path should be transpiled if every parent will also be transpiled, or
+    // if there is no parent.
+    const shouldTranspilePath = [...parents].every((parentPath) => shouldTranspile(parentPath, cache, reasons));
+    cache.set(path, shouldTranspilePath);
+    return shouldTranspilePath;
+};
+const transpileESM = ({ basePath, config, esmPaths, fsCache, reasons, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const cache = new Map();
+    const paths = [...esmPaths].filter((path) => shouldTranspile(path, cache, reasons));
+    const pathsSet = new Set(paths);
+    const packageJsonPaths = [...reasons.entries()]
+        .filter(([path, reason]) => {
+        if ((0, path_1.basename)(path) !== 'package.json') {
+            return false;
+        }
+        const needsPatch = [...reason.parents].some((parentPath) => pathsSet.has(parentPath));
+        return needsPatch;
+    })
+        .map(([path]) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
+    const rewrites = yield getPatchedESMPackages(packageJsonPaths, fsCache);
+    yield Promise.all(paths.map((path) => __awaiter(void 0, void 0, void 0, function* () {
+        const absolutePath = basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path);
+        const transpiled = yield (0, transpile_1.transpile)(absolutePath, config);
+        rewrites.set(absolutePath, transpiled);
+    })));
+    return rewrites;
+});
+exports.transpileESM = transpileESM;
 //# sourceMappingURL=es_modules.js.map

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

@@ -21,11 +21,10 @@ const fs_1 = require("../../../../utils/fs");
 const base_path_1 = require("../../utils/base_path");
 const included_files_1 = require("../../utils/included_files");
 const es_modules_1 = require("./es_modules");
-const transpile_1 = require("./transpile");
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => __awaiter(void 0, void 0, void 0, function* () {
+const bundle = ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { exclude: excludedPaths, paths: includedFilePaths } = yield (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
     const { paths: dependencyPaths, rewrites } = yield traceFilesAndTranspile({
@@ -33,6 +32,7 @@ const bundle = ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot
         config,
         mainFile,
         pluginsModulesPath,
+        transpile: featureFlags.nftTranspile,
     });
     const filteredIncludedPaths = (0, included_files_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
     const dirnames = filteredIncludedPaths.map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath))).sort();
@@ -51,7 +51,7 @@ const ignoreFunction = (path) => {
     const shouldIgnore = ignore.some((expression) => (0, minimatch_1.default)(normalizedPath, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsModulesPath, }) {
+const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsModulesPath, transpile, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const fsCache = {};
         const { fileList: dependencyPaths, esmFileList, reasons, } = yield (0, nft_1.nodeFileTrace)([mainFile], {
@@ -86,10 +86,9 @@ const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsMo
             }),
         });
         const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-        const esmPaths = [...esmFileList].map((path) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
-        const transpiledPaths = yield (0, transpile_1.transpileMany)(esmPaths, config);
-        const patchedESMPackages = yield (0, es_modules_1.getPatchedESMPackages)(esmFileList, reasons, fsCache, basePath);
-        const rewrites = new Map([...transpiledPaths, ...patchedESMPackages]);
+        const rewrites = transpile
+            ? yield (0, es_modules_1.transpileESM)({ basePath, config, esmPaths: esmFileList, fsCache, reasons })
+            : undefined;
         return {
             paths: normalizedDependencyPaths,
             rewrites,

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

@@ -1,3 +1,3 @@
 import type { FunctionConfig } from '../../../../config';
-declare const transpileMany: (paths: string[], config: FunctionConfig) => Promise<Map<string, string>>;
-export { transpileMany };
+declare const transpile: (path: string, config: FunctionConfig) => Promise<string>;
+export { transpile };

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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transpileMany = void 0;
+exports.transpile = void 0;
 const esbuild_1 = require("@netlify/esbuild");
 const bundler_target_1 = require("../esbuild/bundler_target");
 const transpile = (path, config) => __awaiter(void 0, void 0, void 0, function* () {
@@ -27,13 +27,5 @@ const transpile = (path, config) => __awaiter(void 0, void 0, void 0, function*
     });
     return transpiled.outputFiles[0].text;
 });
-const transpileMany = (paths, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const transpiledPaths = new Map();
-    yield Promise.all(paths.map((path) => __awaiter(void 0, void 0, void 0, function* () {
-        const transpiled = yield transpile(path, config);
-        transpiledPaths.set(path, transpiled);
-    })));
-    return transpiledPaths;
-});
-exports.transpileMany = transpileMany;
+exports.transpile = transpile;
 //# sourceMappingURL=transpile.js.map

package/dist/runtimes/node/bundlers/zisi/index.d.ts

@@ -1,6 +1,6 @@
 import type { BundleFunction } from '..';
 declare const bundler: {
     bundle: BundleFunction;
-    getSrcFiles: import("../../../runtime").GetSrcFilesFunction;
+    getSrcFiles: import("..").GetSrcFilesFunction;
 };
 export default bundler;

package/dist/runtimes/node/bundlers/zisi/src_files.d.ts

@@ -1,3 +1,3 @@
-import type { GetSrcFilesFunction } from '../../../runtime';
+import type { GetSrcFilesFunction } from '..';
 declare const getSrcFiles: GetSrcFilesFunction;
 export { getSrcFiles };

package/dist/runtimes/node/index.js

@@ -28,6 +28,7 @@ const cp_file_1 = __importDefault(require("cp-file"));
 const bundlers_1 = require("./bundlers");
 const finder_1 = require("./finder");
 const detect_es_module_1 = require("./utils/detect_es_module");
+const plugin_modules_path_1 = require("./utils/plugin_modules_path");
 const zip_1 = require("./utils/zip");
 // We use ZISI as the default bundler, except for certain extensions, for which
 // esbuild is the only option.
@@ -50,6 +51,7 @@ const getDefaultBundler = ({ extension, mainFile, featureFlags, }) => __awaiter(
 // A proxy for the `getSrcFiles` function which adds a default `bundler` using
 // the `getDefaultBundler` function.
 const getSrcFilesWithBundler = (parameters) => __awaiter(void 0, void 0, void 0, function* () {
+    const pluginsModulesPath = yield (0, plugin_modules_path_1.getPluginsModulesPath)(parameters.srcDir);
     const bundlerName = parameters.config.nodeBundler ||
         (yield getDefaultBundler({
             extension: parameters.extension,
@@ -57,10 +59,11 @@ const getSrcFilesWithBundler = (parameters) => __awaiter(void 0, void 0, void 0,
             mainFile: parameters.mainFile,
         }));
     const bundler = (0, bundlers_1.getBundler)(bundlerName);
-    return bundler.getSrcFiles(Object.assign({}, parameters));
+    return bundler.getSrcFiles(Object.assign(Object.assign({}, parameters), { pluginsModulesPath }));
 });
-const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
+const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
     return __awaiter(this, void 0, void 0, function* () {
+        const pluginsModulesPath = yield (0, plugin_modules_path_1.getPluginsModulesPath)(srcDir);
         const bundlerName = config.nodeBundler || (yield getDefaultBundler({ extension, mainFile, featureFlags }));
         const bundler = (0, bundlers_1.getBundler)(bundlerName);
         // If the file is a zip, we assume the function is bundled and ready to go.
@@ -70,7 +73,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             yield (0, cp_file_1.default)(srcPath, destPath);
             return { config, path: destPath };
         }
-        const { aliases, cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = yield bundler.bundle({
+        const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = yield bundler.bundle({
             basePath,
             config,
             extension,
@@ -85,6 +88,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             srcPath,
             stat,
         });
+        (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
         const zipPath = yield (0, zip_1.zipNodeJs)({
             aliases,
             archiveFormat,
@@ -93,7 +97,6 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             extension,
             filename,
             mainFile: finalMainFile,
-            pluginsModulesPath,
             rewrites,
             srcFiles,
         });

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

@@ -13,5 +13,6 @@ interface PackageJson {
     binary?: boolean;
     type?: string;
 }
+declare const sanitisePackageJson: (packageJson: Record<string, unknown>) => PackageJson;
 declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
-export { getPackageJson, PackageJson };
+export { getPackageJson, PackageJson, sanitisePackageJson };

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

@@ -12,8 +12,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageJson = void 0;
+exports.sanitisePackageJson = exports.getPackageJson = void 0;
 const pkg_dir_1 = __importDefault(require("pkg-dir"));
+const sanitiseFiles = (files) => {
+    if (!Array.isArray(files)) {
+        return undefined;
+    }
+    return files.filter((file) => typeof file === 'string');
+};
+const sanitisePackageJson = (packageJson) => (Object.assign(Object.assign({}, packageJson), { files: sanitiseFiles(packageJson.files) }));
+exports.sanitisePackageJson = sanitisePackageJson;
 // Retrieve the `package.json` of a specific project or module
 const getPackageJson = function (srcDir) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -24,8 +32,9 @@ const getPackageJson = function (srcDir) {
         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
-            return require(packageJsonPath);
+            // 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}`);

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

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

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

@@ -3,9 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPluginsModulesPath = void 0;
+exports.getPluginsModulesPath = exports.createAliases = void 0;
+const path_1 = require("path");
 const find_up_1 = __importDefault(require("find-up"));
 const AUTO_PLUGINS_DIR = '.netlify/plugins/';
+const createAliases = (paths, pluginsModulesPath, aliases, basePath) => {
+    paths.forEach((path) => {
+        if (pluginsModulesPath === undefined || !path.startsWith(pluginsModulesPath)) {
+            return;
+        }
+        const relativePath = (0, path_1.relative)(pluginsModulesPath, path);
+        aliases.set(path, (0, path_1.join)(basePath, 'node_modules', relativePath));
+    });
+};
+exports.createAliases = createAliases;
 const getPluginsModulesPath = (srcDir) => (0, find_up_1.default)(`${AUTO_PLUGINS_DIR}node_modules`, { cwd: srcDir, type: 'directory' });
 exports.getPluginsModulesPath = getPluginsModulesPath;
 //# sourceMappingURL=plugin_modules_path.js.map

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

@@ -6,7 +6,6 @@ interface ZipNodeParameters {
     extension: string;
     filename: string;
     mainFile: string;
-    pluginsModulesPath?: string;
     rewrites?: Map<string, string>;
     srcFiles: string[];
 }

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

@@ -43,7 +43,7 @@ const COPY_FILE_CONCURRENCY = os_1.default.cpus().length === 0 ? 2 : os_1.defaul
 // 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 = function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, rewrites = new Map(), srcFiles, }) {
+const createDirectory = function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, rewrites = new Map(), srcFiles, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const { contents: entryContents, filename: entryFilename } = getEntryFile({
             commonPrefix: basePath,
@@ -63,7 +63,6 @@ const createDirectory = function ({ aliases = new Map(), basePath, destFolder, e
             const normalizedDestPath = normalizeFilePath({
                 commonPrefix: basePath,
                 path: destPath,
-                pluginsModulesPath,
                 userNamespace: DEFAULT_USER_SUBDIRECTORY,
             });
             const absoluteDestPath = (0, path_1.join)(functionFolder, normalizedDestPath);
@@ -75,7 +74,7 @@ const createDirectory = function ({ aliases = new Map(), basePath, destFolder, e
         return functionFolder;
     });
 };
-const createZipArchive = function ({ aliases, basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, rewrites, srcFiles, }) {
+const createZipArchive = function ({ aliases, basePath, destFolder, extension, filename, mainFile, rewrites, srcFiles, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const destPath = (0, path_1.join)(destFolder, `${(0, path_1.basename)(filename, extension)}.zip`);
         const { archive, output } = (0, archive_1.startZip)(destPath);
@@ -103,7 +102,6 @@ const createZipArchive = function ({ aliases, basePath, destFolder, extension, f
                 aliases,
                 archive,
                 commonPrefix: basePath,
-                pluginsModulesPath,
                 rewrites,
                 srcFile,
                 stat,
@@ -141,9 +139,9 @@ const getEntryFile = ({ commonPrefix, filename, mainFile, userNamespace, }) => {
         filename: entryFilename,
     };
 };
-const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, pluginsModulesPath, rewrites = new Map(), stat, srcFile, userNamespace, }) {
+const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrites = new Map(), stat, srcFile, userNamespace, }) {
     const destPath = aliases.get(srcFile) || srcFile;
-    const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, pluginsModulesPath, userNamespace });
+    const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, userNamespace });
     if (rewrites.has(srcFile)) {
         (0, archive_1.addZipContent)(archive, rewrites.get(srcFile), normalizedDestPath);
     }
@@ -154,15 +152,12 @@ const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, plugin
 // `adm-zip` and `require()` expect Unix paths.
 // We remove the common path prefix.
 // With files on different Windows drives, we remove the drive letter.
-const normalizeFilePath = function ({ commonPrefix, path, pluginsModulesPath, userNamespace, }) {
+const normalizeFilePath = function ({ commonPrefix, path, userNamespace, }) {
     const userNamespacePathSegment = userNamespace ? `${userNamespace}${path_1.sep}` : '';
     const pathA = (0, path_1.normalize)(path);
-    const pathB = pluginsModulesPath === undefined
-        ? pathA
-        : pathA.replace(pluginsModulesPath, `${userNamespacePathSegment}node_modules`);
-    const pathC = pathB.replace(commonPrefix, userNamespacePathSegment);
-    const pathD = (0, unixify_1.default)(pathC);
-    return pathD;
+    const pathB = pathA.replace(commonPrefix, userNamespacePathSegment);
+    const pathC = (0, unixify_1.default)(pathB);
+    return pathC;
 };
 /* eslint-enable max-lines */
 //# sourceMappingURL=zip.js.map

package/dist/runtimes/runtime.d.ts

@@ -14,7 +14,6 @@ declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: FeatureFlags;
-    pluginsModulesPath?: string;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<string[]>;
 interface ZipFunctionResult {
@@ -33,7 +32,6 @@ declare type ZipFunction = (args: {
     config: FunctionConfig;
     destFolder: string;
     featureFlags: FeatureFlags;
-    pluginsModulesPath?: string;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<ZipFunctionResult>;
 interface Runtime {

package/dist/zip.d.ts

@@ -6,7 +6,6 @@ interface ZipFunctionOptions {
     basePath?: string;
     config?: Config;
     featureFlags?: FeatureFlags;
-    pluginsModulesPath?: string;
     repositoryRoot?: string;
 }
 declare type ZipFunctionsOptions = ZipFunctionOptions & {
@@ -14,5 +13,5 @@ declare type ZipFunctionsOptions = ZipFunctionOptions & {
     parallelLimit?: number;
 };
 declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<import("./utils/format_result").FunctionResult[]>;
-declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, pluginsModulesPath: defaultModulesPath, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result").FunctionResult | 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 };

package/dist/zip.js

@@ -19,7 +19,6 @@ 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 plugin_modules_path_1 = require("./runtimes/node/utils/plugin_modules_path");
 const archive_size_1 = require("./utils/archive_size");
 const format_result_1 = require("./utils/format_result");
 const fs_1 = require("./utils/fs");
@@ -39,13 +38,7 @@ const zipFunctions = function (relativeSrcFolders, destFolder, { archiveFormat =
         const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
         const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
         const [paths] = yield Promise.all([(0, fs_1.listFunctionsDirectories)(srcFolders), (0, make_dir_1.default)(destFolder)]);
-        const [functions, pluginsModulesPath] = yield Promise.all([
-            (0, runtimes_1.getFunctionsFromPaths)(paths, { config, dedupe: true, featureFlags }),
-            // All function directories should be part of the same project root, so we
-            // can get away with computing the plugins modules path from any of the
-            // source directories.
-            (0, plugin_modules_path_1.getPluginsModulesPath)(srcFolders[0]),
-        ]);
+        const functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { config, dedupe: true, featureFlags });
         const results = yield (0, p_map_1.default)(functions.values(), (func) => __awaiter(this, void 0, void 0, function* () {
             const zipResult = yield func.runtime.zipFunction({
                 archiveFormat,
@@ -56,7 +49,6 @@ const zipFunctions = function (relativeSrcFolders, destFolder, { archiveFormat =
                 filename: func.filename,
                 mainFile: func.mainFile,
                 name: func.name,
-                pluginsModulesPath,
                 repositoryRoot,
                 runtime: func.runtime,
                 srcDir: func.srcDir,
@@ -79,7 +71,7 @@ const zipFunctions = function (relativeSrcFolders, destFolder, { archiveFormat =
     });
 };
 exports.zipFunctions = zipFunctions;
-const zipFunction = function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, pluginsModulesPath: defaultModulesPath, repositoryRoot = basePath, } = {}) {
+const zipFunction = function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         validateArchiveFormat(archiveFormat);
         const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
@@ -89,7 +81,6 @@ const zipFunction = function (relativeSrcPath, destFolder, { archiveFormat = 'zi
             return;
         }
         const { config, extension, filename, mainFile, name, runtime, srcDir, stat: stats, } = functions.values().next().value;
-        const pluginsModulesPath = defaultModulesPath === undefined ? yield (0, plugin_modules_path_1.getPluginsModulesPath)(srcPath) : defaultModulesPath;
         yield (0, make_dir_1.default)(destFolder);
         const zipResult = yield runtime.zipFunction({
             archiveFormat,
@@ -101,7 +92,6 @@ const zipFunction = function (relativeSrcPath, destFolder, { archiveFormat = 'zi
             filename,
             mainFile,
             name,
-            pluginsModulesPath,
             repositoryRoot,
             runtime,
             srcDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "4.28.2",
+  "version": "4.29.2",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -81,7 +81,7 @@
     "p-map": "^4.0.0",
     "path-exists": "^4.0.0",
     "pkg-dir": "^5.0.0",
-    "precinct": "^8.0.0",
+    "precinct": "^8.2.0",
     "read-package-json-fast": "^2.0.2",
     "require-package-name": "^2.0.1",
     "resolve": "^2.0.0-next.1",
@@ -94,7 +94,7 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^3.3.5",
+    "@netlify/eslint-config-node": "^3.3.6",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",
@@ -109,7 +109,7 @@
     "husky": "^4.3.8",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.0.0",
-    "sinon": "^11.1.1",
+    "sinon": "^12.0.0",
     "sort-on": "^4.1.1",
     "throat": "^6.0.1",
     "typescript": "^4.4.3"