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

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.10.0",
+  "version": "5.10.1",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {