@netlify/zip-it-and-ship-it 9.22.0 → 9.23.0

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

@@ -1,15 +1,14 @@
-import { basename, dirname, join, normalize, resolve, extname } from 'path';
+import { basename, dirname, extname, join, normalize, resolve } from 'path';
 import { nodeFileTrace } from '@vercel/nft';
 import resolveDependency from '@vercel/nft/out/resolve-dependency.js';
 import { cachedReadFile, getPathWithExtension } from '../../../../utils/fs.js';
 import { minimatch } from '../../../../utils/matching.js';
 import { getBasePath } from '../../utils/base_path.js';
 import { filterExcludedPaths, getPathsOfIncludedFiles } from '../../utils/included_files.js';
-import { MODULE_FORMAT, MODULE_FILE_EXTENSION, tsExtensions } from '../../utils/module_format.js';
+import { MODULE_FILE_EXTENSION, tsExtensions } from '../../utils/module_format.js';
 import { getNodeSupportMatrix } from '../../utils/node_version.js';
-import { getClosestPackageJson } from '../../utils/package_json.js';
 import { processESM } from './es_modules.js';
-import { transpileTS } from './transpile.js';
+import { transform, getTransformer } from './transformer.js';
 const appearsToBeModuleName = (name) => !name.startsWith('.');
 const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, runtimeAPIVersion, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
@@ -53,65 +52,9 @@ const getIgnoreFunction = (config) => {
         return shouldIgnore;
     };
 };
-/**
- * Returns the module format that should be used when transpiling a TypeScript
- * file.
- */
-const getTSModuleFormat = async (mainFile, runtimeAPIVersion, repositoryRoot) => {
-    // TODO: This check should go away. We should always respect the format from
-    // the extension. We'll do this at a later stage, after we roll out the V2
-    // API with no side-effects on V1 functions.
-    if (runtimeAPIVersion === 2) {
-        if (extname(mainFile) === MODULE_FILE_EXTENSION.MTS) {
-            return MODULE_FORMAT.ESM;
-        }
-        if (extname(mainFile) === MODULE_FILE_EXTENSION.CTS) {
-            return MODULE_FORMAT.COMMONJS;
-        }
-    }
-    // At this point, we need to infer the module type from the `type` field in
-    // the closest `package.json`.
-    try {
-        const packageJSON = await getClosestPackageJson(dirname(mainFile), repositoryRoot);
-        if (packageJSON?.contents.type === 'module') {
-            return MODULE_FORMAT.ESM;
-        }
-    }
-    catch {
-        // no-op
-    }
-    return MODULE_FORMAT.COMMONJS;
-};
-const getTypeScriptTransformer = async (runtimeAPIVersion, mainFile, repositoryRoot) => {
-    const isTypeScript = tsExtensions.has(extname(mainFile));
-    if (!isTypeScript) {
-        return;
-    }
-    const format = await getTSModuleFormat(mainFile, runtimeAPIVersion, repositoryRoot);
-    const aliases = new Map();
-    const rewrites = new Map();
-    const transformer = {
-        aliases,
-        format,
-        rewrites,
-    };
-    if (runtimeAPIVersion === 2) {
-        // For V2 functions, we want to emit a main file with an unambiguous
-        // extension (i.e. `.cjs` or `.mjs`), so that the file is loaded with
-        // the correct format regardless of what is set in `package.json`.
-        const newExtension = format === MODULE_FORMAT.COMMONJS ? MODULE_FILE_EXTENSION.CJS : MODULE_FILE_EXTENSION.MJS;
-        const newMainFile = getPathWithExtension(mainFile, newExtension);
-        return {
-            ...transformer,
-            bundle: true,
-            bundledPaths: [],
-            newMainFile,
-        };
-    }
-    return transformer;
-};
 const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, repositoryRoot, runtimeAPIVersion, }) {
-    const tsTransformer = await getTypeScriptTransformer(runtimeAPIVersion, mainFile, repositoryRoot);
+    const isTSFunction = tsExtensions.has(extname(mainFile));
+    const transformer = runtimeAPIVersion === 2 || isTSFunction ? await getTransformer(runtimeAPIVersion, mainFile, repositoryRoot) : null;
     const { fileList: dependencyPaths, esmFileList, reasons, } = await nodeFileTrace([mainFile], {
         // Default is 1024. Allowing double the fileIO in parallel makes nft faster, but uses a little more memory.
         fileIOConcurrency: 2048,
@@ -120,30 +63,31 @@ const traceFilesAndTranspile = async function ({ basePath, cache, config, featur
         ignore: getIgnoreFunction(config),
         readFile: async (path) => {
             try {
-                const extension = extname(path);
-                if (tsExtensions.has(extension)) {
-                    const { bundledPaths, transpiled } = await transpileTS({
-                        bundle: tsTransformer?.bundle,
+                const isMainFile = path === mainFile;
+                // Transform this file if this is the main file and we're processing a
+                // V2 functions (which always bundle local imports), or if this path is
+                // a TypeScript file (which should only happen for V1 TS functions that
+                // set the bundler to "nft").
+                if ((isMainFile && transformer) || tsExtensions.has(extname(path))) {
+                    const { bundledPaths, transpiled } = await transform({
+                        bundle: transformer?.bundle,
                         config,
                         name,
-                        format: tsTransformer?.format,
+                        format: transformer?.format,
                         path,
                     });
-                    const isMainFile = path === mainFile;
                     // If this is the main file, the final path of the compiled file may
                     // have been set by the transformer. It's fine to do this, since the
                     // only place where this file will be imported from is our entry file
                     // and we'll know the right path to use.
-                    const newPath = isMainFile && tsTransformer?.newMainFile
-                        ? tsTransformer.newMainFile
-                        : getPathWithExtension(path, MODULE_FILE_EXTENSION.JS);
+                    const newPath = transformer?.newMainFile ?? getPathWithExtension(path, MODULE_FILE_EXTENSION.JS);
                     // Overriding the contents of the `.ts` file.
-                    tsTransformer?.rewrites.set(path, transpiled);
+                    transformer?.rewrites.set(path, transpiled);
                     // Rewriting the `.ts` path to `.js` in the bundle.
-                    tsTransformer?.aliases.set(path, newPath);
+                    transformer?.aliases.set(path, newPath);
                     // Registering the input files that were bundled into the transpiled
                     // file.
-                    tsTransformer?.bundledPaths?.push(...bundledPaths);
+                    transformer?.bundledPaths?.push(...bundledPaths);
                     return transpiled;
                 }
                 return await cachedReadFile(cache.fileCache, path);
@@ -172,13 +116,13 @@ const traceFilesAndTranspile = async function ({ basePath, cache, config, featur
         },
     });
     const normalizedTracedPaths = [...dependencyPaths].map((path) => (basePath ? resolve(basePath, path) : resolve(path)));
-    if (tsTransformer) {
+    if (transformer) {
         return {
-            aliases: tsTransformer.aliases,
-            bundledPaths: tsTransformer.bundledPaths,
-            mainFile: tsTransformer.newMainFile ?? getPathWithExtension(mainFile, MODULE_FILE_EXTENSION.JS),
-            moduleFormat: tsTransformer.format,
-            rewrites: tsTransformer.rewrites,
+            aliases: transformer.aliases,
+            bundledPaths: transformer.bundledPaths,
+            mainFile: transformer.newMainFile ?? getPathWithExtension(mainFile, MODULE_FILE_EXTENSION.JS),
+            moduleFormat: transformer.format,
+            rewrites: transformer.rewrites,
             tracedPaths: normalizedTracedPaths,
         };
     }

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

@@ -0,0 +1,23 @@
+import type { FunctionConfig } from '../../../../config.js';
+import { ModuleFormat } from '../../utils/module_format.js';
+type Transformer = {
+    aliases: Map<string, string>;
+    bundle?: boolean;
+    bundledPaths?: string[];
+    format: ModuleFormat;
+    newMainFile?: string;
+    rewrites: Map<string, string>;
+};
+export declare const getTransformer: (runtimeAPIVersion: number, mainFile: string, repositoryRoot?: string) => Promise<Transformer | undefined>;
+interface TransformOptions {
+    bundle?: boolean;
+    config: FunctionConfig;
+    format?: ModuleFormat;
+    name: string;
+    path: string;
+}
+export declare const transform: ({ bundle, config, format, name, path }: TransformOptions) => Promise<{
+    bundledPaths: string[];
+    transpiled: string;
+}>;
+export {};

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

@@ -0,0 +1,101 @@
+import { dirname, extname, resolve } from 'path';
+import { build } from 'esbuild';
+import { FunctionBundlingUserError } from '../../../../utils/error.js';
+import { getPathWithExtension } from '../../../../utils/fs.js';
+import { RUNTIME } from '../../../runtime.js';
+import { CJS_SHIM } from '../../utils/esm_cjs_compat.js';
+import { MODULE_FORMAT, MODULE_FILE_EXTENSION } from '../../utils/module_format.js';
+import { getClosestPackageJson } from '../../utils/package_json.js';
+import { getBundlerTarget } from '../esbuild/bundler_target.js';
+import { NODE_BUNDLER } from '../types.js';
+/**
+ * Returns the module format that should be used for a given function file.
+ */
+const getModuleFormat = async (mainFile, runtimeAPIVersion, repositoryRoot) => {
+    const extension = extname(mainFile);
+    // TODO: This check should go away. We should always respect the format from
+    // the extension. We'll do this at a later stage, after we roll out the V2
+    // API with no side-effects on V1 functions.
+    if (runtimeAPIVersion === 2) {
+        if (extension === MODULE_FILE_EXTENSION.MJS || extension === MODULE_FILE_EXTENSION.MTS) {
+            return MODULE_FORMAT.ESM;
+        }
+        if (extension === MODULE_FILE_EXTENSION.CTS || extension === MODULE_FILE_EXTENSION.CTS) {
+            return MODULE_FORMAT.COMMONJS;
+        }
+    }
+    // At this point, we need to infer the module type from the `type` field in
+    // the closest `package.json`.
+    try {
+        const packageJSON = await getClosestPackageJson(dirname(mainFile), repositoryRoot);
+        if (packageJSON?.contents.type === 'module') {
+            return MODULE_FORMAT.ESM;
+        }
+    }
+    catch {
+        // no-op
+    }
+    return MODULE_FORMAT.COMMONJS;
+};
+export const getTransformer = async (runtimeAPIVersion, mainFile, repositoryRoot) => {
+    const format = await getModuleFormat(mainFile, runtimeAPIVersion, repositoryRoot);
+    const aliases = new Map();
+    const rewrites = new Map();
+    const transformer = {
+        aliases,
+        format,
+        rewrites,
+    };
+    if (runtimeAPIVersion === 2) {
+        // For V2 functions, we want to emit a main file with an unambiguous
+        // extension (i.e. `.cjs` or `.mjs`), so that the file is loaded with
+        // the correct format regardless of what is set in `package.json`.
+        const newExtension = format === MODULE_FORMAT.COMMONJS ? MODULE_FILE_EXTENSION.CJS : MODULE_FILE_EXTENSION.MJS;
+        const newMainFile = getPathWithExtension(mainFile, newExtension);
+        return {
+            ...transformer,
+            bundle: true,
+            bundledPaths: [],
+            newMainFile,
+        };
+    }
+    return transformer;
+};
+export const transform = async ({ bundle = false, config, format, name, path }) => {
+    // The version of ECMAScript to use as the build target. This will determine
+    // whether certain features are transpiled down or left untransformed.
+    const nodeTarget = getBundlerTarget(config.nodeVersion);
+    const bundleOptions = {
+        bundle: false,
+    };
+    if (bundle) {
+        bundleOptions.bundle = true;
+        bundleOptions.packages = 'external';
+        if (format === MODULE_FORMAT.ESM) {
+            bundleOptions.banner = { js: CJS_SHIM };
+        }
+    }
+    try {
+        const transpiled = await build({
+            ...bundleOptions,
+            entryPoints: [path],
+            format,
+            logLevel: 'error',
+            metafile: true,
+            platform: 'node',
+            sourcemap: Boolean(config.nodeSourcemap),
+            target: [nodeTarget],
+            write: false,
+        });
+        const bundledPaths = bundle ? Object.keys(transpiled.metafile.inputs).map((inputPath) => resolve(inputPath)) : [];
+        return { bundledPaths, transpiled: transpiled.outputFiles[0].text };
+    }
+    catch (error) {
+        throw FunctionBundlingUserError.addCustomErrorInfo(error, {
+            functionName: name,
+            runtime: RUNTIME.JAVASCRIPT,
+            bundler: NODE_BUNDLER.NFT,
+        });
+    }
+};
+//# sourceMappingURL=transformer.js.map

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

@@ -1,20 +1,8 @@
 import type { FunctionConfig } from '../../../../config.js';
-import { ModuleFormat } from '../../utils/module_format.js';
 interface TranspileESMToCJSOptions {
     config: FunctionConfig;
     name: string;
     path: string;
 }
 export declare const transpileESMToCJS: ({ config, name, path }: TranspileESMToCJSOptions) => Promise<string>;
-interface TranspileTSOptions {
-    bundle?: boolean;
-    config: FunctionConfig;
-    format?: ModuleFormat;
-    name: string;
-    path: string;
-}
-export declare const transpileTS: ({ bundle, config, format, name, path }: TranspileTSOptions) => Promise<{
-    bundledPaths: string[];
-    transpiled: string;
-}>;
 export {};

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

@@ -1,8 +1,6 @@
-import { resolve } from 'path';
 import { build } from 'esbuild';
 import { FunctionBundlingUserError } from '../../../../utils/error.js';
 import { RUNTIME } from '../../../runtime.js';
-import { CJS_SHIM } from '../../utils/esm_cjs_compat.js';
 import { MODULE_FORMAT } from '../../utils/module_format.js';
 import { getBundlerTarget } from '../esbuild/bundler_target.js';
 import { NODE_BUNDLER } from '../types.js';
@@ -31,41 +29,4 @@ export const transpileESMToCJS = async ({ config, name, path }) => {
         });
     }
 };
-export const transpileTS = async ({ bundle = false, config, format, name, path }) => {
-    // The version of ECMAScript to use as the build target. This will determine
-    // whether certain features are transpiled down or left untransformed.
-    const nodeTarget = getBundlerTarget(config.nodeVersion);
-    const bundleOptions = {
-        bundle: false,
-    };
-    if (bundle) {
-        bundleOptions.bundle = true;
-        bundleOptions.packages = 'external';
-        if (format === MODULE_FORMAT.ESM) {
-            bundleOptions.banner = { js: CJS_SHIM };
-        }
-    }
-    try {
-        const transpiled = await build({
-            ...bundleOptions,
-            entryPoints: [path],
-            format,
-            logLevel: 'error',
-            metafile: true,
-            platform: 'node',
-            sourcemap: Boolean(config.nodeSourcemap),
-            target: [nodeTarget],
-            write: false,
-        });
-        const bundledPaths = bundle ? Object.keys(transpiled.metafile.inputs).map((inputPath) => resolve(inputPath)) : [];
-        return { bundledPaths, transpiled: transpiled.outputFiles[0].text };
-    }
-    catch (error) {
-        throw FunctionBundlingUserError.addCustomErrorInfo(error, {
-            functionName: name,
-            runtime: RUNTIME.JAVASCRIPT,
-            bundler: NODE_BUNDLER.NFT,
-        });
-    }
-};
 //# sourceMappingURL=transpile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "9.22.0",
+  "version": "9.23.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",