@netlify/zip-it-and-ship-it 4.29.4 → 5.1.0

package/dist/feature_flags.js

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

package/dist/main.d.ts

@@ -1,4 +1,3 @@
-import './utils/polyfills';
 import { Config } from './config';
 import { FeatureFlags } from './feature_flags';
 import { RuntimeName } from './runtimes/runtime';

package/dist/main.js

@@ -22,7 +22,6 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 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 fs_1 = require("./utils/fs");

package/dist/manifest.js

@@ -25,11 +25,11 @@ const createManifest = ({ functions, path }) => __awaiter(void 0, void 0, void 0
     yield (0, fs_1.writeFile)(path, JSON.stringify(payload));
 });
 exports.createManifest = createManifest;
-const formatFunctionForManifest = ({ config, mainFile, name, path, runtime }) => ({
+const formatFunctionForManifest = ({ mainFile, name, path, runtime, schedule }) => ({
     mainFile,
     name,
     path: (0, path_1.resolve)(path),
     runtime,
-    schedule: config.schedule,
+    schedule,
 });
 //# sourceMappingURL=manifest.js.map

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

@@ -14,6 +14,7 @@ declare const bundleJsFile: ({ additionalModulePaths, basePath, config, external
     bundlePaths: Map<string, string>;
     cleanTempFiles: () => Promise<void>;
     inputs: string[];
+    iscImporterPaths: Set<string>;
     nativeNodeModules: {};
     nodeModulesWithDynamicImports: string[];
     warnings: import("@netlify/esbuild").Message[];

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

@@ -16,6 +16,7 @@ const tmp_promise_1 = require("tmp-promise");
 const fs_1 = require("../../../../utils/fs");
 const bundler_target_1 = require("./bundler_target");
 const plugin_dynamic_imports_1 = require("./plugin_dynamic_imports");
+const plugin_in_source_config_1 = require("./plugin_in_source_config");
 const plugin_native_modules_1 = require("./plugin_native_modules");
 const plugin_node_builtin_1 = require("./plugin_node_builtin");
 // Maximum number of log messages that an esbuild instance will produce. This
@@ -44,6 +45,7 @@ const bundleJsFile = function ({ additionalModulePaths, basePath, config, extern
         // format) to be included in the bundle in order to make a dynamic import
         // work at runtime.
         const dynamicImportsIncludedPaths = new Set();
+        const iscImporterPaths = new Set();
         // The list of esbuild plugins to enable for this build.
         const plugins = [
             (0, plugin_node_builtin_1.getNodeBuiltinPlugin)(),
@@ -55,6 +57,7 @@ const bundleJsFile = function ({ additionalModulePaths, basePath, config, extern
                 processImports: config.processDynamicNodeImports !== false,
                 srcDir,
             }),
+            (0, plugin_in_source_config_1.getISCImportFinderPlugin)({ importerPaths: iscImporterPaths }),
         ];
         // The version of ECMAScript to use as the build target. This will determine
         // whether certain features are transpiled down or left untransformed.
@@ -92,6 +95,7 @@ const bundleJsFile = function ({ additionalModulePaths, basePath, config, extern
                 bundlePaths,
                 cleanTempFiles,
                 inputs,
+                iscImporterPaths,
                 nativeNodeModules,
                 nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
                 warnings,

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

@@ -39,7 +39,7 @@ const getExternalAndIgnoredModules = ({ config, srcDir }) => __awaiter(void 0, v
 });
 const bundle = ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { externalModules, ignoredModules } = yield getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = yield (0, bundler_1.bundleJsFile)({
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, iscImporterPaths, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = yield (0, bundler_1.bundleJsFile)({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
         basePath,
         config,
@@ -81,6 +81,7 @@ const bundle = ({ basePath, config = {}, extension, featureFlags, filename, main
         basePath: functionBasePath,
         bundlerWarnings,
         inputs,
+        iscImporterPaths,
         mainFile: normalizedMainFile,
         nativeNodeModules,
         nodeModulesWithDynamicImports,

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

@@ -0,0 +1,5 @@
+import type { Plugin } from '@netlify/esbuild';
+declare const getISCImportFinderPlugin: ({ importerPaths }: {
+    importerPaths: Set<string>;
+}) => Plugin;
+export { getISCImportFinderPlugin };

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getISCImportFinderPlugin = void 0;
+const in_source_config_1 = require("../../in_source_config");
+// An esbuild plugin that collects the paths of any files that import the
+// in-source configuration module.
+const getISCImportFinderPlugin = ({ importerPaths }) => ({
+    name: 'find-isc-imports',
+    setup(build) {
+        const filter = new RegExp(`^${in_source_config_1.IN_SOURCE_CONFIG_MODULE}$`);
+        build.onResolve({ filter }, (args) => {
+            importerPaths.add(args.importer);
+            // eslint-disable-next-line unicorn/no-useless-undefined
+            return undefined;
+        });
+    },
+});
+exports.getISCImportFinderPlugin = getISCImportFinderPlugin;
+//# sourceMappingURL=plugin_in_source_config.js.map

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

@@ -19,6 +19,7 @@ declare type BundleFunction = (args: {
     bundlerWarnings?: BundlerWarning[];
     cleanupFunction?: CleanupFunction;
     inputs: string[];
+    iscImporterPaths?: Set<string>;
     mainFile: string;
     nativeNodeModules?: NativeNodeModules;
     nodeModulesWithDynamicImports?: string[];

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

@@ -27,7 +27,7 @@ const patchESMPackage = (path, fsCache) => __awaiter(void 0, void 0, void 0, fun
     const patchedPackageJson = Object.assign(Object.assign({}, packageJson), { type: 'commonjs' });
     return JSON.stringify(patchedPackageJson);
 });
-const shouldTranspile = (path, cache, reasons) => {
+const shouldTranspile = (path, cache, esmPaths, reasons) => {
     if (cache.has(path)) {
         return cache.get(path);
     }
@@ -39,32 +39,33 @@ const shouldTranspile = (path, cache, reasons) => {
         return false;
     }
     const { parents } = reason;
-    // If the path doesn't have any parents, it's safe to transpile.
+    // If the path is an entrypoint, we transpile it only if it's an ESM file.
     if (parents.size === 0) {
-        cache.set(path, true);
-        return true;
+        const isESM = esmPaths.has(path);
+        cache.set(path, isESM);
+        return isESM;
     }
     // 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));
+    const shouldTranspilePath = [...parents].every((parentPath) => shouldTranspile(parentPath, cache, esmPaths, 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 pathsToTranspile = [...esmPaths].filter((path) => shouldTranspile(path, cache, esmPaths, reasons));
+    const pathsToTranspileSet = new Set(pathsToTranspile);
     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));
+        const needsPatch = [...reason.parents].some((parentPath) => pathsToTranspileSet.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* () {
+    yield Promise.all(pathsToTranspile.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);

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

@@ -22,6 +22,7 @@ const transpile = (path, config) => __awaiter(void 0, void 0, void 0, function*
         format: 'cjs',
         logLevel: 'error',
         platform: 'node',
+        sourcemap: Boolean(config.nodeSourcemap),
         target: [nodeTarget],
         write: false,
     });

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

@@ -71,9 +71,7 @@ const getNestedModules = function ({ modulePath, state, packageJson, pluginsModu
     return __awaiter(this, void 0, void 0, function* () {
         const dependencies = (0, nested_1.getNestedDependencies)(packageJson);
         const depsPaths = yield Promise.all(dependencies.map((dependency) => getDependencyPathsForDependency({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
-        // TODO: switch to Array.flat() once we drop support for Node.js < 11.0.0
-        // eslint-disable-next-line unicorn/prefer-spread
-        return [].concat(...depsPaths);
+        return depsPaths.flat();
     });
 };
 //# sourceMappingURL=traverse.js.map

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

@@ -0,0 +1,14 @@
+import { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName } from '@babel/types';
+import { parse as parseSchedule } from './properties/schedule';
+declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
+declare type ISCValues = Partial<ReturnType<typeof parseSchedule>>;
+declare const findISCDeclarationsInPaths: (sourcePaths: string[]) => Promise<Partial<{
+    schedule: string | undefined;
+}>>;
+declare type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
+interface ISCExport {
+    local: string;
+    args: ISCHandlerArg[];
+}
+export { findISCDeclarationsInPaths, IN_SOURCE_CONFIG_MODULE };
+export type { ISCExport, ISCHandlerArg, ISCValues };

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

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IN_SOURCE_CONFIG_MODULE = exports.findISCDeclarationsInPaths = void 0;
+const non_nullable_1 = require("../../../utils/non_nullable");
+const parser_1 = require("../parser");
+const exports_1 = require("../parser/exports");
+const imports_1 = require("../parser/imports");
+const schedule_1 = require("./properties/schedule");
+const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
+exports.IN_SOURCE_CONFIG_MODULE = IN_SOURCE_CONFIG_MODULE;
+// Parses a JS/TS file and looks for in-source config declarations. It returns
+// an array of all declarations found, with `property` indicating the name of
+// the property and `data` its value.
+const findISCDeclarationsInPath = (sourcePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const ast = yield (0, parser_1.safelyParseFile)(sourcePath);
+    if (ast === null) {
+        return {};
+    }
+    const imports = ast.body.map((node) => (0, imports_1.getImports)(node, IN_SOURCE_CONFIG_MODULE)).flat();
+    const exports = (0, exports_1.getMainExport)(ast.body);
+    const iscExports = exports
+        .map(({ args, local: exportName }) => {
+        const matchingImport = imports.find(({ local: importName }) => importName === exportName);
+        if (matchingImport === undefined) {
+            return null;
+        }
+        switch (matchingImport.imported) {
+            case 'schedule':
+                return (0, schedule_1.parse)({ args });
+            default:
+            // no-op
+        }
+        return null;
+    })
+        .filter(non_nullable_1.nonNullable);
+    const mergedExports = iscExports.reduce((acc, obj) => (Object.assign(Object.assign({}, acc), obj)), {});
+    return mergedExports;
+});
+const findISCDeclarationsInPaths = (sourcePaths) => __awaiter(void 0, void 0, void 0, function* () {
+    const paths = yield Promise.all(sourcePaths.map(findISCDeclarationsInPath));
+    const mergedValues = paths.reduce((acc, obj) => (Object.assign(Object.assign({}, acc), obj)), {});
+    return mergedValues;
+});
+exports.findISCDeclarationsInPaths = findISCDeclarationsInPaths;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+import type { ISCHandlerArg } from '..';
+export declare const parse: ({ args }: {
+    args: ISCHandlerArg[];
+}) => {
+    schedule: string | undefined;
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const parse = ({ args }) => {
+    const [expression] = args;
+    const schedule = expression.type === 'StringLiteral' ? expression.value : undefined;
+    return {
+        schedule,
+    };
+};
+exports.parse = parse;
+//# sourceMappingURL=schedule.js.map

package/dist/runtimes/node/index.js

@@ -27,6 +27,7 @@ const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
 const bundlers_1 = require("./bundlers");
 const finder_1 = require("./finder");
+const in_source_config_1 = require("./in_source_config");
 const 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");
@@ -73,7 +74,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             yield (0, cp_file_1.default)(srcPath, destPath);
             return { config, path: destPath };
         }
-        const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = yield bundler.bundle({
+        const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, iscImporterPaths = new Set(), mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = yield bundler.bundle({
             basePath,
             config,
             extension,
@@ -88,6 +89,10 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             srcPath,
             stat,
         });
+        let inSourceConfig = {};
+        if (featureFlags.parseISC) {
+            inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPaths)([...iscImporterPaths]);
+        }
         (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
         const zipPath = yield (0, zip_1.zipNodeJs)({
             aliases,
@@ -106,6 +111,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             bundlerWarnings,
             config,
             inputs,
+            inSourceConfig,
             nativeNodeModules,
             nodeModulesWithDynamicImports,
             path: zipPath,

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

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

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMainExport = void 0;
+const helpers_1 = require("./helpers");
+// Finds the main handler export in an AST.
+const getMainExport = (nodes) => {
+    let handlerExport = [];
+    nodes.find((node) => {
+        const esmExports = getMainExportFromESM(node);
+        if (esmExports.length !== 0) {
+            handlerExport = esmExports;
+            return true;
+        }
+        const cjsExports = getMainExportFromCJS(node);
+        if (cjsExports.length !== 0) {
+            handlerExport = cjsExports;
+            return true;
+        }
+        return false;
+    });
+    return handlerExport;
+};
+exports.getMainExport = getMainExport;
+// Finds the main handler export in a CJS AST.
+const getMainExportFromCJS = (node) => {
+    const handlerPath = ['module', 'exports', 'handler'];
+    if (!(0, helpers_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+        return [];
+    }
+    return getExportsFromCallExpression(node.expression.right);
+};
+// Finds the main handler export in an ESM AST.
+// eslint-disable-next-line complexity
+const getMainExportFromESM = (node) => {
+    var _a;
+    if (node.type !== 'ExportNamedDeclaration' || node.exportKind !== 'value') {
+        return [];
+    }
+    const { declaration } = node;
+    if (!declaration || 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') {
+        return [];
+    }
+    const exports = getExportsFromCallExpression(handlerDeclaration.init);
+    return exports;
+};
+const getExportsFromCallExpression = (node) => {
+    const { arguments: args, callee } = node;
+    if (callee.type !== 'Identifier') {
+        return [];
+    }
+    const exports = [{ local: callee.name, args }];
+    return exports;
+};
+//# sourceMappingURL=exports.js.map

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequire = exports.isModuleExports = exports.isImport = void 0;
+// eslint-disable-next-line complexity
+const isDotExpression = (node, expression) => {
+    if (node.type !== 'MemberExpression') {
+        return false;
+    }
+    const object = expression.slice(0, -1);
+    const [property] = expression.slice(-1);
+    if (node.property.type !== 'Identifier' || node.property.name !== property) {
+        return false;
+    }
+    if (object.length > 1) {
+        return isDotExpression(node.object, object);
+    }
+    return node.object.type === 'Identifier' && object[0] === node.object.name && property === node.property.name;
+};
+const isImport = (node, importPath) => node.type === 'ImportDeclaration' && node.source.value === importPath;
+exports.isImport = isImport;
+const isModuleExports = (node, dotExpression = ['module', 'exports']) => node.type === 'ExpressionStatement' &&
+    node.expression.type === 'AssignmentExpression' &&
+    node.expression.left.type === 'MemberExpression' &&
+    isDotExpression(node.expression.left, dotExpression);
+exports.isModuleExports = isModuleExports;
+const isRequire = (node, requirePath) => {
+    var _a;
+    if (!node || node.type !== 'CallExpression') {
+        return false;
+    }
+    const { arguments: args, callee } = node;
+    const isRequiredModule = ((_a = args[0]) === null || _a === void 0 ? void 0 : _a.type) === 'StringLiteral' && isRequirePath(args[0], requirePath);
+    return isRequireCall(callee) && isRequiredModule;
+};
+exports.isRequire = isRequire;
+const isRequireCall = (node) => node.type === 'Identifier' && node.name === 'require';
+const isRequirePath = (node, path) => node.type === 'StringLiteral' && node.value === path;
+//# sourceMappingURL=helpers.js.map

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

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

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

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

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

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

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

@@ -1,8 +1,19 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseExpression = void 0;
+exports.safelyParseFile = exports.parseExpression = void 0;
+/* eslint-disable max-lines */
 const path_1 = require("path");
 const parser_1 = require("@babel/parser");
+const fs_1 = require("../../../utils/fs");
 const non_nullable_1 = require("../../../utils/non_nullable");
 const GLOB_WILDCARD = '**';
 // Transforms an array of glob nodes into a glob string including an absolute
@@ -75,6 +86,29 @@ const parseExpression = ({ basePath, expression: rawExpression, resolveDir, }) =
     }
 };
 exports.parseExpression = parseExpression;
+// Parses a JS/TS file and returns the resulting AST.
+const parseFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    const code = yield (0, fs_1.readFile)(path, 'utf8');
+    const ast = (0, parser_1.parse)(code, {
+        plugins: ['typescript'],
+        sourceType: 'module',
+    });
+    return ast.program;
+});
+// Attemps to parse a JS/TS file at the given path, returning its AST if
+// successful, or `null` if not.
+const safelyParseFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!path) {
+        return null;
+    }
+    try {
+        return yield parseFile(path);
+    }
+    catch (error) {
+        return null;
+    }
+});
+exports.safelyParseFile = safelyParseFile;
 // Parses a `require()` and returns a glob string with an absolute path.
 const parseRequire = ({ basePath, expression, resolveDir, }) => {
     const { arguments: args = [] } = expression;
@@ -146,4 +180,5 @@ const validateGlobNodes = (globNodes) => {
     const hasStaticHead = globNodes[0] !== GLOB_WILDCARD;
     return hasStrings && hasStaticHead;
 };
+/* eslint-enable max-lines */
 //# sourceMappingURL=index.js.map

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

@@ -36,6 +36,7 @@ const make_dir_1 = __importDefault(require("make-dir"));
 const p_map_1 = __importDefault(require("p-map"));
 const unixify_1 = __importDefault(require("unixify"));
 const archive_1 = require("../../../archive");
+const fs_2 = require("../../../utils/fs");
 const pStat = (0, util_1.promisify)(fs_1.default.stat);
 const pWriteFile = (0, util_1.promisify)(fs_1.default.writeFile);
 // Taken from https://www.npmjs.com/package/cpy.
@@ -67,7 +68,7 @@ const createDirectory = function ({ aliases = new Map(), basePath, destFolder, e
             });
             const absoluteDestPath = (0, path_1.join)(functionFolder, normalizedDestPath);
             if (rewrites.has(srcFile)) {
-                return pWriteFile(absoluteDestPath, rewrites.get(srcFile));
+                return (0, fs_2.mkdirAndWriteFile)(absoluteDestPath, rewrites.get(srcFile));
             }
             return (0, cp_file_1.default)(srcFile, absoluteDestPath);
         }, { concurrency: COPY_FILE_CONCURRENCY });

package/dist/runtimes/runtime.d.ts

@@ -4,6 +4,7 @@ import { FeatureFlags } from '../feature_flags';
 import { FunctionSource, SourceFile } from '../function';
 import { FsCache } from '../utils/fs';
 import type { NodeBundlerName } from './node';
+import type { ISCValues } from './node/in_source_config';
 declare type RuntimeName = 'go' | 'js' | 'rs';
 declare type FindFunctionsInPathsFunction = (args: {
     featureFlags: FeatureFlags;
@@ -22,6 +23,7 @@ interface ZipFunctionResult {
     bundlerWarnings?: object[];
     config: FunctionConfig;
     inputs?: string[];
+    inSourceConfig?: ISCValues;
     nativeNodeModules?: object;
     nodeModulesWithDynamicImports?: string[];
     path: string;

package/dist/utils/format_result.d.ts

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

package/dist/utils/format_result.js

@@ -4,7 +4,8 @@ exports.formatZipResult = void 0;
 const remove_undefined_1 = require("./remove_undefined");
 // Takes the result of zipping a function and formats it for output.
 const formatZipResult = (archive) => {
-    const functionResult = Object.assign(Object.assign({}, archive), { runtime: archive.runtime.name });
+    var _a, _b, _c;
+    const functionResult = Object.assign(Object.assign({}, archive), { inSourceConfig: undefined, 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);
 };
 exports.formatZipResult = formatZipResult;

package/dist/utils/fs.d.ts

@@ -17,5 +17,6 @@ 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[];
-export { cachedLstat, cachedReaddir, cachedReadFile, pLstat as lstat, getPathWithExtension, listFunctionsDirectories, listFunctionsDirectory, resolveFunctionsDirectories, safeUnlink, pStat as stat, pWriteFile as writeFile, pReadFile as readFile, };
+declare const mkdirAndWriteFile: typeof pWriteFile;
+export { cachedLstat, cachedReaddir, cachedReadFile, pLstat as lstat, getPathWithExtension, listFunctionsDirectories, listFunctionsDirectory, resolveFunctionsDirectories, safeUnlink, pStat as stat, pWriteFile as writeFile, pReadFile as readFile, mkdirAndWriteFile, };
 export type { FsCache };

package/dist/utils/fs.js

@@ -8,11 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFile = exports.writeFile = exports.stat = exports.safeUnlink = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.getPathWithExtension = exports.lstat = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
+exports.mkdirAndWriteFile = exports.readFile = exports.writeFile = exports.stat = exports.safeUnlink = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.getPathWithExtension = exports.lstat = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const util_1 = require("util");
+const make_dir_1 = __importDefault(require("make-dir"));
 const non_nullable_1 = require("./non_nullable");
 const pLstat = (0, util_1.promisify)(fs_1.lstat);
 exports.lstat = pLstat;
@@ -93,4 +97,12 @@ const resolveFunctionsDirectories = (input) => {
     return absoluteDirectories;
 };
 exports.resolveFunctionsDirectories = resolveFunctionsDirectories;
+const mkdirAndWriteFile = (path, ...params) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof path === 'string') {
+        const directory = (0, path_1.dirname)(path);
+        yield (0, make_dir_1.default)(directory);
+    }
+    return pWriteFile(path, ...params);
+});
+exports.mkdirAndWriteFile = mkdirAndWriteFile;
 //# sourceMappingURL=fs.js.map

package/dist/zip.d.ts

@@ -12,6 +12,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<import("./utils/format_result").FunctionResult[]>;
+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;
+    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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "4.29.4",
+  "version": "5.1.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -61,7 +61,6 @@
     "@netlify/esbuild": "^0.13.6",
     "@vercel/nft": "^0.17.0",
     "archiver": "^5.3.0",
-    "array-flat-polyfill": "^1.0.1",
     "common-path-prefix": "^3.0.0",
     "cp-file": "^9.0.0",
     "del": "^6.0.0",
@@ -94,7 +93,7 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^3.3.6",
+    "@netlify/eslint-config-node": "^3.3.8",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",
@@ -109,13 +108,15 @@
     "husky": "^4.3.8",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.0.0",
+    "p-every": "^2.0.0",
     "sinon": "^12.0.0",
     "sort-on": "^4.1.1",
+    "source-map-support": "^0.5.20",
     "throat": "^6.0.1",
     "typescript": "^4.4.3"
   },
   "engines": {
-    "node": ">=10.18.0"
+    "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
   },
   "ava": {
     "files": [

package/dist/utils/polyfills.d.ts

@@ -1 +0,0 @@
-import 'array-flat-polyfill';

package/dist/utils/polyfills.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Patches `Array.flat()` and `Array.flatMap()`
-// TODO: remove after dropping Node <12 support
-require("array-flat-polyfill");
-//# sourceMappingURL=polyfills.js.map