@netlify/zip-it-and-ship-it 13.0.1 → 13.1.0

package/dist/main.d.ts

@@ -1,10 +1,12 @@
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
+import { type MixedPaths } from './paths.js';
 import { ModuleFormat } from './runtimes/node/utils/module_format.js';
 import { RuntimeName } from './runtimes/runtime.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 export { Config, FunctionConfig } from './config.js';
-export { type FunctionsBag, zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
+export { zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
+export type { FunctionsBag } from './paths.js';
 export { ArchiveFormat, ARCHIVE_FORMAT } from './archive.js';
 export type { TrafficRules } from './rate_limit.js';
 export type { ExtendedRoute, Route } from './utils/routes.js';
@@ -37,7 +39,7 @@ interface ListFunctionsOptions {
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC }?: ListFunctionsOptions) => Promise<ListedFunction[]>;
+export declare const listFunctions: (input: MixedPaths, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC }?: ListFunctionsOptions) => Promise<ListedFunction[]>;
 interface ListFunctionOptions {
     basePath?: string;
     config?: Config;

package/dist/main.js

@@ -1,5 +1,6 @@
 import { extname } from 'path';
 import { getFlags } from './feature_flags.js';
+import { getFunctionsBag } from './paths.js';
 import { getFunctionFromPath, getFunctionsFromPaths } from './runtimes/index.js';
 import { parseFile } from './runtimes/node/in_source_config/index.js';
 import { RUNTIME } from './runtimes/runtime.js';
@@ -20,12 +21,18 @@ const augmentWithStaticAnalysis = async (func) => {
     return { ...func, staticAnalysisResult };
 };
 // List all Netlify Functions main entry files for a specific directory.
-export const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false } = {}) {
+export const listFunctions = async function (input, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
-    const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
+    const bag = getFunctionsBag(input);
+    const srcFolders = resolveFunctionsDirectories([...bag.generated.directories, ...bag.user.directories]);
     const paths = await listFunctionsDirectories(srcFolders);
     const cache = new RuntimeCache();
-    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
+    const functionsMap = await getFunctionsFromPaths([...paths, ...bag.generated.functions, ...bag.user.functions], {
+        cache,
+        config,
+        configFileDirectories,
+        featureFlags,
+    });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC
         ? await Promise.all(functions.map((func) => augmentWithStaticAnalysis(func)))

package/dist/paths.d.ts

@@ -0,0 +1,35 @@
+export interface FunctionsBag {
+    generated: FunctionsCategory;
+    user: FunctionsCategory;
+}
+export interface FunctionsCategory {
+    /**
+     * List of paths for directories containing one or more functions. Entries in
+     * these directories are considered functions when they are files that match
+     * one of the supported extensions or when they are sub-directories that
+     * contain a function following the sub-directory naming patterns.
+     * Paths can be relative.
+     */
+    directories: string[];
+    /**
+     * List of paths for specific functions. Paths can be files that match one
+     * of the supported extensions or sub-directories that contain a function
+     * following the sub-directory naming patterns. Paths can be relative.
+     */
+    functions: string[];
+}
+export type MixedPaths = string | string[] | {
+    /**
+     * Functions generated on behalf of the user by a build plugin, extension
+     * or a framework.
+     */
+    generated?: Partial<FunctionsCategory>;
+    /**
+     * Functions authored by the user.
+     */
+    user?: Partial<FunctionsCategory>;
+};
+/**
+ * Normalizes the `zipFunctions` input into a `FunctionsBag` object.
+ */
+export declare const getFunctionsBag: (input: MixedPaths) => FunctionsBag;

package/dist/paths.js

@@ -0,0 +1,39 @@
+/**
+ * Normalizes the `zipFunctions` input into a `FunctionsBag` object.
+ */
+export const getFunctionsBag = (input) => {
+    if (typeof input === 'string') {
+        return {
+            generated: {
+                directories: [],
+                functions: [],
+            },
+            user: {
+                directories: [input],
+                functions: [],
+            },
+        };
+    }
+    if (Array.isArray(input)) {
+        return {
+            generated: {
+                directories: [],
+                functions: [],
+            },
+            user: {
+                directories: input,
+                functions: [],
+            },
+        };
+    }
+    return {
+        generated: {
+            directories: input.generated?.directories ?? [],
+            functions: input.generated?.functions ?? [],
+        },
+        user: {
+            directories: input.user?.directories ?? [],
+            functions: input.user?.functions ?? [],
+        },
+    };
+};

package/dist/utils/fs.js

@@ -78,5 +78,6 @@ export const mkdirAndWriteFile = async (path, ...params) => {
         const directory = dirname(path);
         await fs.mkdir(directory, { recursive: true });
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     return fs.writeFile(path, ...params);
 };

package/dist/zip.d.ts

@@ -1,6 +1,7 @@
 import { ArchiveFormat } from './archive.js';
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
+import { type MixedPaths } from './paths.js';
 import { FunctionResult } from './utils/format_result.js';
 import { LogFunction } from './utils/logger.js';
 export interface ZipFunctionOptions {
@@ -20,40 +21,5 @@ export type ZipFunctionsOptions = ZipFunctionOptions & {
     manifest?: string;
     parallelLimit?: number;
 };
-export interface FunctionsBag {
-    generated: FunctionsCategory;
-    user: FunctionsCategory;
-}
-export interface FunctionsCategory {
-    /**
-     * List of paths for directories containing one or more functions. Entries in
-     * these directories are considered functions when they are files that match
-     * one of the supported extensions or when they are sub-directories that
-     * contain a function following the sub-directory naming patterns.
-     * Paths can be relative.
-     */
-    directories: string[];
-    /**
-     * List of paths for specific functions. Paths can be files that match one
-     * of the supported extensions or sub-directories that contain a function
-     * following the sub-directory naming patterns. Paths can be relative.
-     */
-    functions: string[];
-}
-/**
- * Normalizes the `zipFunctions` input into a `FunctionsBag` object.
- */
-export declare const getFunctionsBag: (input: ZipFunctionsPaths) => FunctionsBag;
-export type ZipFunctionsPaths = string | string[] | {
-    /**
-     * Functions generated on behalf of the user by a build plugin, extension
-     * or a framework.
-     */
-    generated?: Partial<FunctionsCategory>;
-    /**
-     * Functions authored by the user.
-     */
-    user?: Partial<FunctionsCategory>;
-};
-export declare const zipFunctions: (input: ZipFunctionsPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
+export declare const zipFunctions: (input: MixedPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
 export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionOptions) => Promise<FunctionResult | undefined>;

package/dist/zip.js

@@ -7,6 +7,7 @@ import { getFlags } from './feature_flags.js';
 import { createManifest } from './manifest.js';
 import { getFunctionsFromPaths } from './runtimes/index.js';
 import { MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
+import { getFunctionsBag } from './paths.js';
 import { addArchiveSize } from './utils/archive_size.js';
 import { RuntimeCache } from './utils/cache.js';
 import { formatZipResult } from './utils/format_result.js';
@@ -19,45 +20,6 @@ const validateArchiveFormat = (archiveFormat) => {
         throw new Error(`Invalid archive format: ${archiveFormat}`);
     }
 };
-/**
- * Normalizes the `zipFunctions` input into a `FunctionsBag` object.
- */
-export const getFunctionsBag = (input) => {
-    if (typeof input === 'string') {
-        return {
-            generated: {
-                directories: [],
-                functions: [],
-            },
-            user: {
-                directories: [input],
-                functions: [],
-            },
-        };
-    }
-    if (Array.isArray(input)) {
-        return {
-            generated: {
-                directories: [],
-                functions: [],
-            },
-            user: {
-                directories: input,
-                functions: [],
-            },
-        };
-    }
-    return {
-        generated: {
-            directories: input.generated?.directories ?? [],
-            functions: input.generated?.functions ?? [],
-        },
-        user: {
-            directories: input.user?.directories ?? [],
-            functions: input.user?.functions ?? [],
-        },
-    };
-};
 // Zip `srcFolder/*` (Node.js or Go files) to `destFolder/*.zip` so it can be
 // used by AWS Lambda
 export const zipFunctions = async function (input, destFolder, { archiveFormat = ARCHIVE_FORMAT.ZIP, basePath, branch, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "13.0.1",
+  "version": "13.1.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "e471abe7b07fb8a34110d06bd8857c89f1d84142"
+  "gitHead": "8b4d1bc0bf7986ac48b4cb46e92f04f8cd8be987"
 }