@netlify/zip-it-and-ship-it 5.9.1 → 5.10.1

package/dist/config.js

@@ -5,14 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfigForFunction = void 0;
 const merge_options_1 = __importDefault(require("merge-options"));
-const minimatch_1 = __importDefault(require("minimatch"));
+const matching_js_1 = require("./utils/matching.js");
 const getConfigForFunction = ({ config, func, }) => {
     if (!config) {
         return {};
     }
     // It's safe to mutate the array because it's local to this function.
     const matches = Object.keys(config)
-        .filter((expression) => (0, minimatch_1.default)(func.name, expression))
+        .filter((expression) => (0, matching_js_1.minimatch)(func.name, expression))
         .map((expression) => {
         const wildcardCount = [...expression].filter((char) => char === '*').length;
         // The weight increases with the number of hardcoded (i.e. non-wildcard)

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

@@ -8,8 +8,8 @@ declare const versionMap: {
 };
 declare type VersionKeys = keyof typeof versionMap;
 declare type VersionValues = typeof versionMap[VersionKeys];
-declare const getBundlerTarget: (suppliedVersion?: string | undefined) => VersionValues;
-declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, configVersion?: string | undefined) => Promise<{
+declare const getBundlerTarget: (suppliedVersion?: string) => VersionValues;
+declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, configVersion?: string) => Promise<{
     includedFiles: string[];
     moduleFormat: ModuleFormat;
 }>;

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

@@ -42,7 +42,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         srcFile: mainFile,
     });
     const bundlerWarnings = warnings.length === 0 ? undefined : warnings;
-    const srcFiles = await (0, src_files_js_1.getSrcFiles)({
+    const { srcFiles, includedFiles } = await (0, src_files_js_1.getSrcFiles)({
         basePath,
         config: {
             ...config,
@@ -77,6 +77,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         cleanupFunction: cleanTempFiles,
         basePath: functionBasePath,
         bundlerWarnings,
+        includedFiles,
         inputs,
         mainFile: normalizedMainFile,
         moduleFormat,

package/dist/runtimes/node/bundlers/esbuild/plugin_dynamic_imports.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDynamicImportsPlugin = void 0;
 const path_1 = require("path");
 const find_up_1 = __importDefault(require("find-up"));
+const normalize_path_1 = __importDefault(require("normalize-path"));
 const read_package_json_fast_1 = __importDefault(require("read-package-json-fast"));
-const unixify_1 = __importDefault(require("unixify"));
 const index_js_1 = require("../../parser/index.js");
 // This plugin intercepts module imports using dynamic expressions and does a
 // couple of things with them. First of all, it figures out whether the call
@@ -81,7 +81,7 @@ const getShimContents = ({ expressionType, resolveDir, srcDir, }) => {
     // relative to the main bundle file, since esbuild will flatten everything
     // into a single file.
     const relativeResolveDir = (0, path_1.relative)(srcDir, resolveDir);
-    const requireArg = relativeResolveDir ? `\`./${(0, unixify_1.default)(relativeResolveDir)}/$\{args}\`` : 'args';
+    const requireArg = relativeResolveDir ? `\`./${(0, normalize_path_1.default)(relativeResolveDir)}/$\{args}\`` : 'args';
     if (expressionType === 'require') {
         return `module.exports = args => require(${requireArg})`;
     }

package/dist/runtimes/node/bundlers/esbuild/src_files.js

@@ -7,14 +7,18 @@ const traversal_cache_js_1 = require("../../utils/traversal_cache.js");
 const traverse_js_1 = require("../zisi/traverse.js");
 const getSrcFiles = async ({ config, mainFile, pluginsModulesPath, srcDir }) => {
     const { externalNodeModules = [], includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
+    const { excludePatterns, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
     const dependencyPaths = await getSrcFilesForDependencies({
         dependencies: externalNodeModules,
         basedir: srcDir,
         pluginsModulesPath,
     });
-    const includedPaths = (0, included_files_js_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
-    return [...includedPaths, mainFile];
+    const srcFiles = (0, included_files_js_1.filterExcludedPaths)(dependencyPaths, excludePatterns);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)(includedFilePaths, excludePatterns);
+    return {
+        srcFiles: [...srcFiles, ...includedPaths, mainFile],
+        includedFiles: includedPaths,
+    };
 };
 exports.getSrcFiles = getSrcFiles;
 const getSrcFilesForDependencies = async function ({ dependencies: dependencyNames, basedir, state = (0, traversal_cache_js_1.getNewCache)(), pluginsModulesPath, }) {

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

@@ -19,6 +19,7 @@ export declare type BundleFunction = (args: {
     basePath: string;
     bundlerWarnings?: BundlerWarning[];
     cleanupFunction?: CleanupFunction;
+    includedFiles: string[];
     inputs: string[];
     mainFile: string;
     moduleFormat: ModuleFormat;
@@ -32,7 +33,10 @@ export declare type GetSrcFilesFunction = (args: {
     featureFlags: FeatureFlags;
     pluginsModulesPath?: string;
     repositoryRoot?: string;
-} & FunctionSource) => Promise<string[]>;
+} & FunctionSource) => Promise<{
+    srcFiles: string[];
+    includedFiles: string[];
+}>;
 interface NodeBundler {
     bundle: BundleFunction;
     getSrcFiles: GetSrcFilesFunction;

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

@@ -3,7 +3,7 @@ import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
 import { FsCache } from '../../../../utils/fs.js';
 import { ModuleFormat } from '../../utils/module_format.js';
-export declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }: {
+export declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, name, }: {
     basePath: string | undefined;
     config: FunctionConfig;
     esmPaths: Set<string>;
@@ -11,6 +11,7 @@ export declare const processESM: ({ basePath, config, esmPaths, featureFlags, fs
     fsCache: FsCache;
     mainFile: string;
     reasons: NodeFileTraceReasons;
+    name: string;
 }) => Promise<{
     rewrites?: Map<string, string> | undefined;
     moduleFormat: ModuleFormat;

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

@@ -28,7 +28,7 @@ const patchESMPackage = async (path, fsCache) => {
     };
     return JSON.stringify(patchedPackageJson);
 };
-const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }) => {
+const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, name, }) => {
     const entrypointIsESM = isEntrypointESM({ basePath, esmPaths, mainFile });
     if (!entrypointIsESM) {
         return {
@@ -42,7 +42,7 @@ const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, m
             moduleFormat: 'esm',
         };
     }
-    const rewrites = await transpileESM({ basePath, config, esmPaths, fsCache, reasons });
+    const rewrites = await transpileESM({ basePath, config, esmPaths, fsCache, reasons, name });
     return {
         moduleFormat: 'cjs',
         rewrites,
@@ -75,7 +75,7 @@ const shouldTranspile = (path, cache, esmPaths, reasons) => {
     cache.set(path, shouldTranspilePath);
     return shouldTranspilePath;
 };
-const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, }) => {
+const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, name, }) => {
     const cache = new Map();
     const pathsToTranspile = [...esmPaths].filter((path) => shouldTranspile(path, cache, esmPaths, reasons));
     const pathsToTranspileSet = new Set(pathsToTranspile);
@@ -91,7 +91,7 @@ const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, }) =
     const rewrites = await getPatchedESMPackages(packageJsonPaths, fsCache);
     await Promise.all(pathsToTranspile.map(async (path) => {
         const absolutePath = resolvePath(path, basePath);
-        const transpiled = await (0, transpile_js_1.transpile)(absolutePath, config);
+        const transpiled = await (0, transpile_js_1.transpile)(absolutePath, config, name);
         rewrites.set(absolutePath, transpiled);
     }));
     return rewrites;

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

@@ -1,5 +1,4 @@
-import type { GetSrcFilesFunction } from '../../../runtime.js';
-import type { BundleFunction } from '../index.js';
+import type { GetSrcFilesFunction, BundleFunction } from '../index.js';
 declare const bundler: {
     bundle: BundleFunction;
     getSrcFiles: GetSrcFilesFunction;

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

@@ -6,31 +6,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const nft_1 = require("@vercel/nft");
 const resolve_dependency_js_1 = __importDefault(require("@vercel/nft/out/resolve-dependency.js"));
-const minimatch_1 = __importDefault(require("minimatch"));
-const unixify_1 = __importDefault(require("unixify"));
 const fs_js_1 = require("../../../../utils/fs.js");
+const matching_js_1 = require("../../../../utils/matching.js");
 const base_path_js_1 = require("../../utils/base_path.js");
 const included_files_js_1 = require("../../utils/included_files.js");
 const es_modules_js_1 = require("./es_modules.js");
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = async ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
+const bundle = async ({ basePath, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
+    const { excludePatterns, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
     const { moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
         config,
         featureFlags,
         mainFile,
         pluginsModulesPath,
+        name,
     });
-    const filteredIncludedPaths = (0, included_files_js_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)(includedFilePaths, excludePatterns);
+    const filteredIncludedPaths = [...(0, included_files_js_1.filterExcludedPaths)(dependencyPaths, excludePatterns), ...includedPaths];
     const dirnames = filteredIncludedPaths.map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath))).sort();
     // Sorting the array to make the checksum deterministic.
     const srcFiles = [...filteredIncludedPaths].sort();
     return {
         basePath: (0, base_path_js_1.getBasePath)(dirnames),
+        includedFiles: includedPaths,
         inputs: dependencyPaths,
         mainFile,
         moduleFormat,
@@ -39,11 +41,10 @@ const bundle = async ({ basePath, config, featureFlags, mainFile, pluginsModules
     };
 };
 const ignoreFunction = (path) => {
-    const normalizedPath = (0, unixify_1.default)(path);
-    const shouldIgnore = ignore.some((expression) => (0, minimatch_1.default)(normalizedPath, expression));
+    const shouldIgnore = ignore.some((expression) => (0, matching_js_1.minimatch)(path, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = async function ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, }) {
+const traceFilesAndTranspile = async function ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, name, }) {
     const fsCache = {};
     const { fileList: dependencyPaths, esmFileList, reasons, } = await (0, nft_1.nodeFileTrace)([mainFile], {
         base: basePath,
@@ -85,6 +86,7 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
         fsCache,
         mainFile,
         reasons,
+        name,
     });
     return {
         moduleFormat,
@@ -94,11 +96,15 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
 };
 const getSrcFiles = async function ({ basePath, config, mainFile }) {
     const { includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
+    const { excludePatterns, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
     const { fileList: dependencyPaths } = await (0, nft_1.nodeFileTrace)([mainFile], { base: basePath, ignore: ignoreFunction });
     const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-    const includedPaths = (0, included_files_js_1.filterExcludedPaths)([...normalizedDependencyPaths, ...includedFilePaths], excludedPaths);
-    return includedPaths;
+    const srcFiles = (0, included_files_js_1.filterExcludedPaths)(normalizedDependencyPaths, excludePatterns);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)(includedFilePaths, excludePatterns);
+    return {
+        srcFiles: [...srcFiles, ...includedPaths],
+        includedFiles: includedPaths,
+    };
 };
 const bundler = { bundle, getSrcFiles };
 exports.default = bundler;

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

@@ -1,2 +1,2 @@
 import type { FunctionConfig } from '../../../../config.js';
-export declare const transpile: (path: string, config: FunctionConfig) => Promise<string>;
+export declare const transpile: (path: string, config: FunctionConfig, functionName: string) => Promise<string>;

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

@@ -3,21 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transpile = void 0;
 const esbuild_1 = require("@netlify/esbuild");
 const bundler_target_js_1 = require("../esbuild/bundler_target.js");
-const transpile = async (path, config) => {
+const transpile = async (path, config, functionName) => {
     // The version of ECMAScript to use as the build target. This will determine
     // whether certain features are transpiled down or left untransformed.
     const nodeTarget = (0, bundler_target_js_1.getBundlerTarget)(config.nodeVersion);
-    const transpiled = await (0, esbuild_1.build)({
-        bundle: false,
-        entryPoints: [path],
-        format: 'cjs',
-        logLevel: 'error',
-        platform: 'node',
-        sourcemap: Boolean(config.nodeSourcemap),
-        target: [nodeTarget],
-        write: false,
-    });
-    return transpiled.outputFiles[0].text;
+    try {
+        const transpiled = await (0, esbuild_1.build)({
+            bundle: false,
+            entryPoints: [path],
+            format: 'cjs',
+            logLevel: 'error',
+            platform: 'node',
+            sourcemap: Boolean(config.nodeSourcemap),
+            target: [nodeTarget],
+            write: false,
+        });
+        return transpiled.outputFiles[0].text;
+    }
+    catch (error) {
+        const bundler = 'nft';
+        const runtime = 'js';
+        error.customErrorInfo = {
+            type: 'functionsBundling',
+            location: { bundler, functionName, runtime },
+        };
+        throw error;
+    }
 };
 exports.transpile = transpile;
 //# sourceMappingURL=transpile.js.map

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

@@ -4,7 +4,7 @@ const path_1 = require("path");
 const base_path_js_1 = require("../../utils/base_path.js");
 const src_files_js_1 = require("./src_files.js");
 const bundle = async ({ basePath, config, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, runtime, srcDir, srcPath, stat, }) => {
-    const srcFiles = await (0, src_files_js_1.getSrcFiles)({
+    const { srcFiles, includedFiles } = await (0, src_files_js_1.getSrcFiles)({
         basePath,
         config: {
             ...config,
@@ -24,6 +24,7 @@ const bundle = async ({ basePath, config, extension, featureFlags, filename, mai
     const dirnames = srcFiles.map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath)));
     return {
         basePath: (0, base_path_js_1.getBasePath)(dirnames),
+        includedFiles,
         inputs: srcFiles,
         mainFile,
         moduleFormat: 'cjs',

package/dist/runtimes/node/bundlers/zisi/published.js

@@ -1,16 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPublishedFiles = void 0;
-const util_1 = require("util");
-const glob_1 = __importDefault(require("glob"));
-const pGlob = (0, util_1.promisify)(glob_1.default);
+const matching_1 = require("../../../../utils/matching");
 // We use all the files published by the Node.js except some that are not needed
 const getPublishedFiles = async function (modulePath) {
     const ignore = getIgnoredFiles(modulePath);
-    const publishedFiles = await pGlob(`${modulePath}/**`, {
+    const publishedFiles = await (0, matching_1.glob)(`${modulePath}/**`, {
         ignore,
         nodir: true,
         absolute: true,

package/dist/runtimes/node/bundlers/zisi/src_files.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -29,10 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSrcFiles = void 0;
 /* eslint-disable max-lines */
 const path_1 = require("path");
-const process = __importStar(require("process"));
 const junk_1 = require("junk");
 const precinct_1 = __importDefault(require("precinct"));
-const semver_1 = __importDefault(require("semver"));
 const non_nullable_js_1 = require("../../../../utils/non_nullable.js");
 const included_files_js_1 = require("../../utils/included_files.js");
 const package_json_js_1 = require("../../utils/package_json.js");
@@ -47,7 +22,7 @@ const tree_shake_js_1 = require("./tree_shake.js");
 // has a size limit for the zipped file. It also makes cold starts faster.
 const getSrcFiles = async function ({ config, featureFlags, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) {
     const { includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
+    const { excludePatterns, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
     const [treeFiles, depFiles] = await Promise.all([
         (0, tree_files_js_1.getTreeFiles)(srcPath, stat),
         getDependencies({ featureFlags, functionName: name, mainFile, pluginsModulesPath, srcDir }),
@@ -57,8 +32,9 @@ const getSrcFiles = async function ({ config, featureFlags, mainFile, name, plug
     // We sort so that the archive's checksum is deterministic.
     // Mutating is fine since `Array.filter()` returns a shallow copy
     const filteredFiles = uniqueFiles.filter(isNotJunk).sort();
-    const includedPaths = (0, included_files_js_1.filterExcludedPaths)([...filteredFiles, ...includedFilePaths], excludedPaths);
-    return includedPaths;
+    const srcFiles = (0, included_files_js_1.filterExcludedPaths)(filteredFiles, excludePatterns);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)(includedFilePaths, excludePatterns);
+    return { srcFiles: [...srcFiles, ...includedPaths], includedFiles: includedPaths };
 };
 exports.getSrcFiles = getSrcFiles;
 // Remove temporary files like *~, *.swp, etc.
@@ -84,34 +60,15 @@ const getDependencies = async function ({ featureFlags, functionName, mainFile,
         throw error;
     }
 };
-const paperwork = async (path) => {
-    if (semver_1.default.lt(process.version, '18.0.0')) {
-        return await precinct_1.default.paperwork(path, { includeCore: false });
-    }
-    // for Node v18, we're temporarily using our own mechanism to filter out core dependencies, until
-    // https://github.com/dependents/node-precinct/pull/108 landed
-    const modules = await precinct_1.default.paperwork(path, { includeCore: true });
-    return modules.filter((moduleName) => {
-        if (moduleName.startsWith('node:')) {
-            return false;
-        }
-        // only require("node:test") refers to the
-        // builtin, require("test") doesn't
-        if (moduleName === 'test') {
-            return true;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const isNativeModule = moduleName in process.binding('natives');
-        return !isNativeModule;
-    });
-};
 const getFileDependencies = async function ({ featureFlags, functionName, path, packageJson, pluginsModulesPath, state, treeShakeNext = false, }) {
     if (state.localFiles.has(path)) {
         return [];
     }
     state.localFiles.add(path);
     const basedir = (0, path_1.dirname)(path);
-    const dependencies = featureFlags.parseWithEsbuild ? await (0, list_imports_js_1.listImports)({ functionName, path }) : await paperwork(path);
+    const dependencies = featureFlags.parseWithEsbuild
+        ? await (0, list_imports_js_1.listImports)({ functionName, path })
+        : await precinct_1.default.paperwork(path, { includeCore: false });
     const depsPaths = await Promise.all(dependencies.filter(non_nullable_js_1.nonNullable).map((dependency) => getImportDependencies({
         dependency,
         basedir,

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

@@ -1,2 +1,2 @@
-import { Stats } from 'fs';
+import type { Stats } from 'fs';
 export declare const getTreeFiles: (srcPath: string, stat: Stats) => Promise<string[]>;

package/dist/runtimes/node/bundlers/zisi/tree_files.js

@@ -1,18 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTreeFiles = void 0;
-const util_1 = require("util");
-const glob_1 = __importDefault(require("glob"));
-const pGlob = (0, util_1.promisify)(glob_1.default);
+const matching_1 = require("../../../../utils/matching");
 // When using a directory, we include all its descendants except `node_modules`
 const getTreeFiles = async function (srcPath, stat) {
     if (!stat.isDirectory()) {
         return [srcPath];
     }
-    return await pGlob(`${srcPath}/**`, {
+    return await (0, matching_1.glob)(`${srcPath}/**`, {
         ignore: `${srcPath}/**/node_modules/**`,
         nodir: true,
         absolute: true,

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findISCDeclarationsInPath = exports.IN_SOURCE_CONFIG_MODULE = void 0;
 const non_nullable_js_1 = require("../../../utils/non_nullable.js");
+const bindings_js_1 = require("../parser/bindings.js");
 const exports_js_1 = require("../parser/exports.js");
 const imports_js_1 = require("../parser/imports.js");
 const index_js_1 = require("../parser/index.js");
@@ -16,7 +17,8 @@ const findISCDeclarationsInPath = async (sourcePath) => {
         return {};
     }
     const imports = ast.body.flatMap((node) => (0, imports_js_1.getImports)(node, exports.IN_SOURCE_CONFIG_MODULE));
-    const mainExports = (0, exports_js_1.getMainExport)(ast.body);
+    const getAllBindings = (0, bindings_js_1.createBindingsMethod)(ast.body);
+    const mainExports = (0, exports_js_1.getMainExport)(ast.body, getAllBindings);
     const iscExports = mainExports
         .map(({ args, local: exportName }) => {
         const matchingImport = imports.find(({ local: importName }) => importName === exportName);
@@ -25,7 +27,7 @@ const findISCDeclarationsInPath = async (sourcePath) => {
         }
         switch (matchingImport.imported) {
             case 'schedule':
-                return (0, schedule_js_1.parse)({ args });
+                return (0, schedule_js_1.parse)({ args }, getAllBindings);
             default:
             // no-op
         }

package/dist/runtimes/node/in_source_config/properties/schedule.d.ts

@@ -1,6 +1,7 @@
+import type { BindingMethod } from '../../parser/bindings.js';
 import type { ISCHandlerArg } from '../index.js';
 export declare const parse: ({ args }: {
     args: ISCHandlerArg[];
-}) => {
+}, getAllBindings: BindingMethod) => {
     schedule: string | undefined;
 };

package/dist/runtimes/node/in_source_config/properties/schedule.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = void 0;
-const parse = ({ args }) => {
-    const [expression] = args;
+const parse = ({ args }, getAllBindings) => {
+    let [expression] = args;
+    if (expression.type === 'Identifier') {
+        const binding = getAllBindings().get(expression.name);
+        if (binding) {
+            expression = binding;
+        }
+    }
     const schedule = expression.type === 'StringLiteral' ? expression.value : undefined;
     return {
         schedule,

package/dist/runtimes/node/index.js

@@ -21,7 +21,8 @@ const getSrcFilesWithBundler = async (parameters) => {
             mainFile: parameters.mainFile,
         }));
     const bundler = (0, index_js_1.getBundler)(bundlerName);
-    return bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
+    const result = await bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
+    return result.srcFiles;
 };
 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_js_1.getPluginsModulesPath)(srcDir);
@@ -34,7 +35,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         await (0, cp_file_1.default)(srcPath, destPath);
         return { config, path: destPath };
     }
-    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
+    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, includedFiles, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
         basePath,
         config,
         extension,
@@ -69,6 +70,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         bundlerWarnings,
         config,
         inputs,
+        includedFiles,
         inSourceConfig,
         nativeNodeModules,
         nodeModulesWithDynamicImports,

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

@@ -0,0 +1,5 @@
+import type { Expression, Statement } from '@babel/types';
+declare type Bindings = Map<string, Expression>;
+export declare type BindingMethod = () => Bindings;
+export declare const createBindingsMethod: (nodes: Statement[]) => BindingMethod;
+export {};

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBindingsMethod = void 0;
+const getBindingFromVariableDeclaration = function (node, bindings) {
+    node.declarations.forEach((declaration) => {
+        if (declaration.id.type === 'Identifier' && declaration.init) {
+            bindings.set(declaration.id.name, declaration.init);
+        }
+    });
+};
+// eslint-disable-next-line complexity
+const getBindingsFromNode = function (node, bindings) {
+    var _a;
+    if (node.type === 'VariableDeclaration') {
+        // A variable was created, so create it and store the potential value
+        getBindingFromVariableDeclaration(node, bindings);
+    }
+    else if (node.type === 'ExpressionStatement' &&
+        node.expression.type === 'AssignmentExpression' &&
+        node.expression.left.type === 'Identifier') {
+        // The variable was reassigned, so let's store the new value
+        bindings.set(node.expression.left.name, node.expression.right);
+    }
+    else if (node.type === 'ExportNamedDeclaration' && ((_a = node.declaration) === null || _a === void 0 ? void 0 : _a.type) === 'VariableDeclaration') {
+        // A `export const|let ...` creates a binding that can later be referenced again
+        getBindingFromVariableDeclaration(node.declaration, bindings);
+    }
+};
+/**
+ * Goes through all relevant nodes and creates a map from binding name to assigned value/expression
+ */
+const getAllBindings = function (nodes) {
+    const bindings = new Map();
+    nodes.forEach((node) => {
+        getBindingsFromNode(node, bindings);
+    });
+    return bindings;
+};
+const createBindingsMethod = function (nodes) {
+    // memoize the result for these nodes
+    let result;
+    return () => {
+        if (!result) {
+            result = getAllBindings(nodes);
+        }
+        return result;
+    };
+};
+exports.createBindingsMethod = createBindingsMethod;
+//# sourceMappingURL=bindings.js.map

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

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

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMainExport = void 0;
 const helpers_js_1 = require("./helpers.js");
 // Finds the main handler export in an AST.
-const getMainExport = (nodes) => {
+const getMainExport = (nodes, getAllBindings) => {
     let handlerExport = [];
     nodes.find((node) => {
-        const esmExports = getMainExportFromESM(node);
+        const esmExports = getMainExportFromESM(node, getAllBindings);
         if (esmExports.length !== 0) {
             handlerExport = esmExports;
             return true;
@@ -28,34 +28,58 @@ const getMainExportFromCJS = (node) => {
         ['exports', 'handler'],
     ];
     return handlerPaths.flatMap((handlerPath) => {
-        if (!(0, helpers_js_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+        if (!(0, helpers_js_1.isModuleExports)(node, handlerPath)) {
             return [];
         }
-        return getExportsFromCallExpression(node.expression.right);
+        return getExportsFromExpression(node.expression.right);
     });
 };
 // Finds the main handler export in an ESM AST.
-// eslint-disable-next-line complexity
-const getMainExportFromESM = (node) => {
-    var _a;
+const getMainExportFromESM = (node, getAllBindings) => {
     if (node.type !== 'ExportNamedDeclaration' || node.exportKind !== 'value') {
         return [];
     }
-    const { declaration } = node;
-    if (!declaration || declaration.type !== 'VariableDeclaration') {
+    const { declaration, specifiers } = node;
+    if ((specifiers === null || specifiers === void 0 ? void 0 : specifiers.length) > 0) {
+        return getExportsFromBindings(specifiers, getAllBindings);
+    }
+    if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'VariableDeclaration') {
         return [];
     }
     const handlerDeclaration = declaration.declarations.find((childDeclaration) => {
         const { id, type } = childDeclaration;
         return type === 'VariableDeclarator' && id.type === 'Identifier' && id.name === 'handler';
     });
-    if (((_a = handlerDeclaration === null || handlerDeclaration === void 0 ? void 0 : handlerDeclaration.init) === null || _a === void 0 ? void 0 : _a.type) !== 'CallExpression') {
+    const exports = getExportsFromExpression(handlerDeclaration === null || handlerDeclaration === void 0 ? void 0 : handlerDeclaration.init);
+    return exports;
+};
+// Check if the Node is an ExportSpecifier that has a named export called `handler`
+// either with Identifier `export { handler }`
+// or with StringLiteral `export { x as "handler" }`
+const isHandlerExport = (node) => {
+    const { type, exported } = node;
+    return (type === 'ExportSpecifier' &&
+        ((exported.type === 'Identifier' && exported.name === 'handler') ||
+            (exported.type === 'StringLiteral' && exported.value === 'handler')));
+};
+// Tries to resolve the export from a binding (variable)
+// for example `let handler; handler = () => {}; export { handler }` would
+// resolve correctly to the handler function
+const getExportsFromBindings = (specifiers, getAllBindings) => {
+    const specifier = specifiers.find(isHandlerExport);
+    if (!specifier) {
         return [];
     }
-    const exports = getExportsFromCallExpression(handlerDeclaration.init);
+    const binding = getAllBindings().get(specifier.local.name);
+    const exports = getExportsFromExpression(binding);
     return exports;
 };
-const getExportsFromCallExpression = (node) => {
+const getExportsFromExpression = (node) => {
+    // We're only interested in expressions representing function calls, because
+    // the ISC patterns we implement at the moment are all helper functions.
+    if ((node === null || node === void 0 ? void 0 : node.type) !== 'CallExpression') {
+        return [];
+    }
     const { arguments: args, callee } = node;
     if (callee.type !== 'Identifier') {
         return [];

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

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

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

@@ -1,51 +1,46 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPathsOfIncludedFiles = exports.filterExcludedPaths = void 0;
 const path_1 = require("path");
-const util_1 = require("util");
-const glob_1 = __importDefault(require("glob"));
-const minimatch_1 = __importDefault(require("minimatch"));
-const pGlob = (0, util_1.promisify)(glob_1.default);
+const matching_1 = require("../../../utils/matching");
 // Returns the subset of `paths` that don't match any of the glob expressions
 // from `exclude`.
-const filterExcludedPaths = (paths, exclude = []) => {
-    if (exclude.length === 0) {
+const filterExcludedPaths = (paths, excludePattern = []) => {
+    if (excludePattern.length === 0) {
         return paths;
     }
-    const excludedPaths = paths.filter((path) => !exclude.some((pattern) => (0, minimatch_1.default)(path, pattern)));
+    const excludedPaths = paths.filter((path) => !excludePattern.some((pattern) => (0, matching_1.minimatch)(path, pattern)));
     return excludedPaths;
 };
 exports.filterExcludedPaths = filterExcludedPaths;
 const getPathsOfIncludedFiles = async (includedFiles, basePath) => {
     if (basePath === undefined) {
-        return { exclude: [], paths: [] };
+        return { excludePatterns: [], paths: [] };
     }
     // Some of the globs in `includedFiles` might be exclusion patterns, which
     // means paths that should NOT be included in the bundle. We need to treat
     // these differently, so we iterate on the array and put those paths in a
     // `exclude` array and the rest of the paths in an `include` array.
-    const { include, exclude } = includedFiles.reduce((acc, path) => {
+    const { include, excludePatterns } = includedFiles.reduce((acc, path) => {
         if (path.startsWith('!')) {
-            const excludePath = (0, path_1.resolve)(basePath, path.slice(1));
+            // convert to unix paths, as minimatch does not support windows paths in patterns
+            const excludePattern = (0, path_1.resolve)(basePath, path.slice(1));
             return {
                 include: acc.include,
-                exclude: [...acc.exclude, excludePath],
+                excludePatterns: [...acc.excludePatterns, excludePattern],
             };
         }
         return {
             include: [...acc.include, path],
-            exclude: acc.exclude,
+            excludePatterns: acc.excludePatterns,
         };
-    }, { include: [], exclude: [] });
-    const pathGroups = await Promise.all(include.map((expression) => pGlob(expression, { absolute: true, cwd: basePath, ignore: exclude, nodir: true })));
+    }, { include: [], excludePatterns: [] });
+    const pathGroups = await Promise.all(include.map((expression) => (0, matching_1.glob)(expression, { absolute: true, cwd: basePath, ignore: excludePatterns, nodir: true })));
     // `pathGroups` is an array containing the paths for each expression in the
     // `include` array. We flatten it into a single dimension.
     const paths = pathGroups.flat();
     const normalizedPaths = paths.map(path_1.normalize);
-    return { exclude, paths: [...new Set(normalizedPaths)] };
+    return { excludePatterns, paths: [...new Set(normalizedPaths)] };
 };
 exports.getPathsOfIncludedFiles = getPathsOfIncludedFiles;
 //# sourceMappingURL=included_files.js.map

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

@@ -4,7 +4,7 @@ export interface NodeVersionSupport {
     esm: boolean;
 }
 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 getNodeVersion: (configVersion?: string) => number;
+export declare const getNodeSupportMatrix: (configVersion?: string) => NodeVersionSupport;
 export declare const parseVersion: (input: string | undefined) => number | undefined;
 export {};

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

@@ -7,7 +7,6 @@ exports.sanitisePackageJson = exports.getPackageJsonIfAvailable = exports.getPac
 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 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
@@ -31,11 +30,9 @@ const getClosestPackageJson = async (resolveDir) => {
 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 {};
-    }
-    return readPackageJson(`${packageRoot}/package.json`);
+    var _a;
+    const result = await (0, exports.getClosestPackageJson)(srcDir);
+    return (_a = result === null || result === void 0 ? void 0 : result.contents) !== null && _a !== void 0 ? _a : {};
 };
 exports.getPackageJson = getPackageJson;
 const getPackageJsonIfAvailable = async (srcDir) => {

package/dist/runtimes/runtime.d.ts

@@ -28,6 +28,7 @@ export interface ZipFunctionResult {
     bundlerWarnings?: object[];
     config: FunctionConfig;
     inputs?: string[];
+    includedFiles?: string[];
     inSourceConfig?: ISCValues;
     nativeNodeModules?: object;
     nodeModulesWithDynamicImports?: string[];

package/dist/utils/fs.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { promises as fs } from 'fs';
 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>;

package/dist/utils/matching.d.ts

@@ -0,0 +1,9 @@
+import globFunction from 'glob';
+import minimatchFunction from 'minimatch';
+/**
+ * Both glob and minimatch only support unix style slashes in patterns
+ * For this reason we wrap them and ensure all patters are always unixified
+ * We use `normalize-path` here instead of `unixify` because we do not want to remove drive letters
+ */
+export declare const glob: (pattern: string, options: globFunction.IOptions) => Promise<string[]>;
+export declare const minimatch: (target: string, pattern: string, options?: minimatchFunction.IOptions) => boolean;

package/dist/utils/matching.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minimatch = exports.glob = void 0;
+const util_1 = require("util");
+const glob_1 = __importDefault(require("glob"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const normalize_path_1 = __importDefault(require("normalize-path"));
+const pGlob = (0, util_1.promisify)(glob_1.default);
+/**
+ * Both glob and minimatch only support unix style slashes in patterns
+ * For this reason we wrap them and ensure all patters are always unixified
+ * We use `normalize-path` here instead of `unixify` because we do not want to remove drive letters
+ */
+const glob = function (pattern, options) {
+    let normalizedIgnore;
+    if (options.ignore) {
+        normalizedIgnore =
+            typeof options.ignore === 'string'
+                ? (0, normalize_path_1.default)(options.ignore)
+                : options.ignore.map((expression) => (0, normalize_path_1.default)(expression));
+    }
+    return pGlob((0, normalize_path_1.default)(pattern), { ...options, ignore: normalizedIgnore });
+};
+exports.glob = glob;
+const minimatch = function (target, pattern, options) {
+    return (0, minimatch_1.default)(target, (0, normalize_path_1.default)(pattern), options);
+};
+exports.minimatch = minimatch;
+//# sourceMappingURL=matching.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.9.1",
+  "version": "5.10.1",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -53,8 +53,8 @@
   },
   "dependencies": {
     "@babel/parser": "7.16.8",
-    "@netlify/esbuild": "0.14.23",
-    "@vercel/nft": "^0.18.0",
+    "@netlify/esbuild": "0.14.25",
+    "@vercel/nft": "^0.19.0",
     "archiver": "^5.3.0",
     "common-path-prefix": "^3.0.0",
     "cp-file": "^9.0.0",
@@ -65,16 +65,16 @@
     "execa": "^5.0.0",
     "filter-obj": "^2.0.1",
     "find-up": "^5.0.0",
-    "glob": "^7.1.6",
+    "glob": "^8.0.3",
     "is-builtin-module": "^3.1.0",
     "junk": "^3.1.0",
     "locate-path": "^6.0.0",
     "merge-options": "^3.0.4",
-    "minimatch": "^4.0.0",
+    "minimatch": "^5.0.0",
+    "normalize-path": "^3.0.0",
     "p-map": "^4.0.0",
     "path-exists": "^4.0.0",
-    "pkg-dir": "^5.0.0",
-    "precinct": "^8.2.0",
+    "precinct": "^9.0.1",
     "read-package-json-fast": "^2.0.2",
     "require-package-name": "^2.0.1",
     "resolve": "^2.0.0-next.1",
@@ -82,13 +82,14 @@
     "tmp-promise": "^3.0.2",
     "toml": "^3.0.0",
     "unixify": "^1.0.0",
-    "yargs": "^16.0.0"
+    "yargs": "^17.0.0"
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
     "@netlify/eslint-config-node": "^6.0.0",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
+    "@types/normalize-path": "^3.0.0",
     "@types/resolve": "^1.20.1",
     "@types/semver": "^7.3.8",
     "@types/unixify": "^1.0.0",