vite-plugin-vercel 11.0.0-beta.2 → 11.0.0-beta.3

package/dist/types.d.ts

@@ -12,6 +12,11 @@ type ViteVercelRedirect = Redirect & {
 };
 type PluginContext = ThisParameterType<Extract<Plugin["resolveId"], (...args: never) => any>>;
 interface ViteVercelConfig {
+  /**
+   * @experimental
+   * @default basic
+   */
+  bundleStrategy?: "basic" | "nf3";
   /**
    * How long Functions should be allowed to run for every request, in seconds.
    * If left empty, default value for your plan will be used.

package/dist/vite.js

@@ -1,20 +1,22 @@
 import { t as pathRelativeTo$1 } from "./path-B4ThGm96.js";
-import { r as assert, t as createAPI } from "./api-DR2y7JVQ.js";
+import { n as getVercelAPI, r as assert, t as createAPI } from "./api-DR2y7JVQ.js";
+import { builtinModules } from "node:module";
 import path from "node:path";
 import { vercelOutputConfigSchema, vercelOutputPrerenderConfigSchema, vercelOutputVcConfigSchema } from "@vite-plugin-vercel/schemas";
 import { fromRou3 } from "convert-route/rou3";
 import { BuildEnvironment, createRunnableDevEnvironment, mergeConfig, normalizePath } from "vite";
 import { catchAll, devServer } from "@universal-deploy/store/vite";
 import { store } from "@universal-deploy/store";
-import fs from "node:fs";
+import fs, { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { copyFile, cp, rmdir, unlink } from "node:fs/promises";
+import { findRoot } from "@manypkg/find-root";
+import { nodeFileTrace, resolve } from "@vercel/nft";
+import { build } from "rolldown";
 import { cpus } from "node:os";
-import { resolve } from "@vercel/nft";
 import { externals } from "nf3/plugin";
 import pLimit from "p-limit";
-import { build } from "rolldown";
 import { getNodeVersion } from "@vercel/build-utils";
 import { toPathToRegexpV6 } from "convert-route/path-to-regexp-v6";
-import { cp } from "node:fs/promises";
 import { getTransformedRoutes, mergeRoutes, normalizeRoutes } from "@vercel/routing-utils";
 
 //#region src/utils/dedupeRoutes.ts
@@ -75,10 +77,10 @@ function apiPlugin(pluginConfig) {
 		applyToEnvironment({ name }) {
 			return name === "vercel_edge" || name === "vercel_node";
 		},
-		writeBundle(_opts, bundle$1) {
+		writeBundle(_opts, bundle$2) {
 			const root = this.environment.config.root ?? process.cwd();
 			const entryMapByDestination = new Map(dedupeRoutes().map((e) => [entryDestination(root, e, ".func/index"), e]));
-			for (const [key, value] of Object.entries(bundle$1)) if (value.type === "chunk" && entryMapByDestination.has(removeExtension$1(key))) outfiles.push({
+			for (const [key, value] of Object.entries(bundle$2)) if (value.type === "chunk" && entryMapByDestination.has(removeExtension$1(key))) outfiles.push({
 				type: "chunk",
 				root: this.environment.config.root,
 				outdir: this.environment.config.build.outDir,
@@ -96,6 +98,17 @@ function apiPlugin(pluginConfig) {
 	};
 }
 
+//#endregion
+//#region src/utils/edge.ts
+const edgeConditions = [
+	"edge-light",
+	"worker",
+	"browser",
+	"module",
+	"import",
+	"default"
+];
+
 //#endregion
 //#region src/utils/external.ts
 const _external = [
@@ -108,8 +121,209 @@ const _external = [
 const edgeExternal = [..._external, ..._external.map((e) => `node:${e}`)];
 
 //#endregion
-//#region src/plugins/bundle.ts
-function bundlePlugin() {
+//#region src/plugins/bundle/basic.ts
+const builtIns = new Set(builtinModules.flatMap((m) => [m, `node:${m}`]));
+const edgeWasmPlugin = {
+	name: "edge-wasm-vercel",
+	resolveId: {
+		filter: { id: [/\.wasm\?module$/] },
+		handler(id) {
+			return {
+				id: id.replace(/\.wasm\?module$/, ".wasm"),
+				external: true
+			};
+		}
+	}
+};
+const dynamicNativeImportPlugin = {
+	name: "edge-dynamic-import-native",
+	resolveDynamicImport(specifier) {
+		if (typeof specifier === "string" && builtIns.has(specifier)) return {
+			id: specifier,
+			external: true
+		};
+	}
+};
+const reactEdgePlugin$1 = {
+	name: "react-edge-plugin",
+	resolveId: {
+		filter: { id: [/react-dom\/server/] },
+		async handler(_id, importer, options) {
+			return this.resolve("react-dom/server.edge", importer, options);
+		}
+	}
+};
+function basicBundlePlugin() {
+	const bundledAssets = /* @__PURE__ */ new Map();
+	const bundledChunks = [];
+	return [{
+		name: "vite-plugin-vercel:bundle",
+		enforce: "post",
+		apply: "build",
+		generateBundle(_opts, bundle$2) {
+			for (const b of Object.values(bundle$2)) {
+				const outFile = joinAbsolute(this.environment, this.environment.config.build.outDir, b.fileName);
+				if (b.type === "asset") {
+					const originalFileNames = b.originalFileNames.map((relativePath) => path.resolve(this.environment.config.root, relativePath));
+					const asset = {
+						env: this.environment.name,
+						root: this.environment.config.root,
+						outDir: this.environment.config.build.outDir,
+						outFile,
+						fileName: b.fileName
+					};
+					for (const originalFileName of originalFileNames) bundledAssets.set(originalFileName, asset);
+				} else bundledChunks.push(outFile);
+			}
+		},
+		closeBundle: {
+			order: "post",
+			async handler() {
+				if (!isVercelLastBuildStep(this.environment)) return;
+				this.environment.logger.info("Creating Vercel bundles...");
+				const outfiles = getVercelAPI(this).getOutFiles();
+				const filesToKeep = [];
+				for (const outfile of outfiles) if (outfile.type === "chunk") filesToKeep.push(...await bundle$1(this, bundledAssets, outfile));
+				await cleanup$1(filesToKeep, bundledChunks);
+			}
+		},
+		sharedDuringBuild: true
+	}];
+}
+function getAbsoluteOutFile(outfile) {
+	const source = joinAbsolutePosix(outfile.root, outfile.outdir, outfile.filepath);
+	return {
+		source,
+		destination: source.replace(outfile.outdir, outfile.outdir)
+	};
+}
+async function bundle$1(pluginContext, bundledAssets, outfile) {
+	const output = [];
+	const { source, destination } = getAbsoluteOutFile(outfile);
+	const isEdge = Boolean(outfile.relatedEntry.vercel?.edge);
+	const { environment } = pluginContext;
+	const buildOptions = {};
+	buildOptions.output = {
+		format: "esm",
+		legalComments: "none"
+	};
+	buildOptions.checks = { pluginTimings: false };
+	buildOptions.input = [source];
+	buildOptions.treeshake = true;
+	buildOptions.resolve ??= {};
+	if (isEdge) {
+		buildOptions.platform = "browser";
+		buildOptions.external = edgeExternal;
+		buildOptions.resolve.conditionNames = edgeConditions;
+		buildOptions.transform = { define: { "process.env.NODE_ENV": JSON.stringify("production") } };
+		buildOptions.output.file = destination.replace(/\.mjs$/, ".js");
+		buildOptions.plugins = [
+			edgeWasmPlugin,
+			dynamicNativeImportPlugin,
+			reactEdgePlugin$1
+		];
+	} else {
+		buildOptions.platform = "node";
+		buildOptions.output.file = destination.replace(/\.js$/, ".mjs");
+		buildOptions.output.banner = `import { createRequire as topLevelCreateRequire } from 'node:module';
+import { dirname as topLevelDirname } from 'node:path';
+import { fileURLToPath as topLevelFileURLToPath } from 'node:url';
+var require = topLevelCreateRequire(import.meta.url);
+var __filename = topLevelFileURLToPath(import.meta.url);
+var __dirname = topLevelDirname(__filename);
+`;
+	}
+	try {
+		await build(buildOptions);
+		output.push(buildOptions.output.file);
+	} catch (e) {
+		throw new Error(`Error while bundling ${destination}`, { cause: e });
+	}
+	let base = environment.config.root;
+	try {
+		base = (await findRoot(environment.config.root)).rootDir;
+	} catch (_e) {}
+	const resolvedEntryP = pluginContext.resolve(outfile.relatedEntry.id);
+	const entryFilePath = existsSync(outfile.relatedEntry.id) ? outfile.relatedEntry.id : (await resolvedEntryP)?.id && existsSync((await resolvedEntryP).id) ? (await resolvedEntryP).id : null;
+	if (entryFilePath === null) return [];
+	const { fileList, reasons } = await nodeFileTrace([entryFilePath], {
+		base,
+		processCwd: environment.config.root,
+		mixedModules: true,
+		ignore: [
+			"**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js",
+			"**/*.d.ts",
+			"**/*.map",
+			"**/node_modules/webpack5/**/*"
+		],
+		async readFile(filepath) {
+			if (filepath.endsWith(".ts") || filepath.endsWith(".tsx")) return (await build({
+				output: {
+					format: "esm",
+					minify: false
+				},
+				external: /.*/,
+				platform: "node",
+				logLevel: "info",
+				plugins: [],
+				transform: { define: {
+					"process.env.NODE_ENV": "\"production\"",
+					"import.meta.env.NODE_ENV": "\"production\""
+				} },
+				input: [entryFilePath],
+				write: false
+			})).output[0].code;
+			return readFileSync(filepath, "utf-8");
+		}
+	});
+	for (const file of fileList) if (reasons.has(file) && reasons.get(file)?.type.includes("asset") && !file.endsWith(".js") && !file.endsWith(".cjs") && !file.endsWith(".mjs") && !file.endsWith("package.json")) {
+		const absolutePath = path.join(base, file);
+		const assetRenamedByVite = bundledAssets.get(absolutePath);
+		const basename = path.basename(assetRenamedByVite ? assetRenamedByVite.fileName : absolutePath);
+		if (assetRenamedByVite) writeFileSync(destination, readFileSync(destination, "utf-8").replaceAll(`/${assetRenamedByVite.fileName}`, `./${path.basename(assetRenamedByVite.fileName)}`));
+		const to = path.join(path.dirname(destination), basename);
+		output.push(to);
+		await copyFile(absolutePath, to);
+	}
+	return output;
+}
+function joinAbsolute(env_or_p0, p1, ...p) {
+	if (path.isAbsolute(p1)) return path.join(p1, ...p);
+	return path.join(typeof env_or_p0 === "string" ? env_or_p0 : env_or_p0.config.root, p1, ...p);
+}
+function joinAbsolutePosix(env_or_p0, p1, ...p) {
+	if (path.isAbsolute(p1)) return path.posix.join(p1, ...p);
+	return path.posix.join(typeof env_or_p0 === "string" ? env_or_p0 : env_or_p0.config.root, p1, ...p);
+}
+function isVercelLastBuildStep(env) {
+	return (typeof env !== "string" ? env.name : env) === "vercel_node";
+}
+async function cleanup$1(filesToKeep, bundledChunks) {
+	const toKeep = new Set(filesToKeep);
+	const removedFiles = [];
+	await Promise.all(bundledChunks.map(async (file) => {
+		if (!toKeep.has(file)) try {
+			await unlink(file);
+			removedFiles.push(file);
+		} catch {}
+	}));
+	const dirsToRemove = /* @__PURE__ */ new Set();
+	for (const file of removedFiles) {
+		let dir = path.dirname(file);
+		while (dir && dir !== "." && dir !== "/" && !toKeep.has(dir)) {
+			dirsToRemove.add(dir);
+			dir = path.dirname(dir);
+		}
+	}
+	const sortedDirs = Array.from(dirsToRemove).sort((a, b) => b.length - a.length);
+	for (const dir of sortedDirs) try {
+		await rmdir(dir);
+	} catch {}
+}
+
+//#endregion
+//#region src/plugins/bundle/nf3.ts
+function nf3BundlePlugin() {
 	const externalsPlugin = externals({});
 	delete externalsPlugin.buildEnd;
 	let buildOutput;
@@ -133,13 +347,20 @@ function bundlePlugin() {
 				fileName: e[1].fileName,
 				outPath: path.join(outDir$1, e[1].fileName)
 			}));
-			assert(entries.length > 0, "No entry files found in build output");
+			if (entries.length === 0) return;
 			const outPaths = entries.map((entry) => entry.outPath);
 			const input = Object.fromEntries(outPaths.map((e) => [removeExtension(pathRelativeTo(e, outDir$1)), e]));
 			const limit = pLimit(Math.max(1, Math.ceil(cpus().length / 2)));
+			const nonVitePlugins = this.environment.config.plugins.filter((p) => {
+				return !p.name.startsWith("vite:") && p.name !== "alias" && p.name !== "commonjs" && p.name !== "nitro:externals";
+			}).map((x) => {
+				const { buildStart, buildEnd, writeBundle, generateBundle, ...rest } = x;
+				return rest;
+			});
 			const localOutput = (await Promise.all(Object.values(input).map((entryPath) => limit(async () => {
 				const outDir$2 = path.dirname(entryPath);
 				return { output: (await bundle({
+					plugins: nonVitePlugins,
 					isEdge,
 					input: { index: entryPath },
 					outDir: outDir$2,
@@ -169,7 +390,7 @@ function bundle(options) {
 		platform: options.isEdge ? "browser" : "node",
 		external: options.isEdge ? edgeExternal : [],
 		write: true,
-		plugins: [externals(options.externals)],
+		plugins: [...options.plugins, externals(options.externals)],
 		input: options.input,
 		resolve: { conditionNames: options.externals.conditions },
 		output: {
@@ -435,17 +656,6 @@ function getConfig(pluginConfig) {
 //#region src/utils/const.ts
 const virtualEntry = "virtual:vite-plugin-vercel:entry";
 
-//#endregion
-//#region src/utils/edge.ts
-const edgeConditions = [
-	"edge-light",
-	"worker",
-	"browser",
-	"module",
-	"import",
-	"default"
-];
-
 //#endregion
 //#region src/plugins/setupEnvs.ts
 const outDir = path.posix.join(process.cwd(), ".vercel/output");
@@ -467,27 +677,30 @@ function setupEnvs(pluginConfig) {
 					await builder.build(builder.environments.vercel_node);
 				}
 			},
-			config() {
-				if (!injected) {
-					injected = true;
-					if (pluginConfig.entries) store.entries.push(...pluginConfig.entries);
+			config: {
+				order: "post",
+				handler() {
+					if (!injected) {
+						injected = true;
+						if (pluginConfig.entries) store.entries.push(...pluginConfig.entries);
+					}
+					const outDirOverride = pluginConfig.outDir ? { build: { outDir: pluginConfig.outDir } } : {};
+					return {
+						environments: {
+							vercel_edge: createVercelEnvironmentOptions(outDirOverride),
+							vercel_node: createVercelEnvironmentOptions(outDirOverride),
+							vercel_client: {
+								build: {
+									outDir: path.join(pluginConfig.outDir ?? outDir, "static"),
+									copyPublicDir: true,
+									rollupOptions: { input: getDummyInput() }
+								},
+								consumer: "client"
+							}
+						},
+						builder: {}
+					};
 				}
-				const outDirOverride = pluginConfig.outDir ? { build: { outDir: pluginConfig.outDir } } : {};
-				return {
-					environments: {
-						vercel_edge: createVercelEnvironmentOptions(outDirOverride),
-						vercel_node: createVercelEnvironmentOptions(outDirOverride),
-						vercel_client: {
-							build: {
-								outDir: path.join(pluginConfig.outDir ?? outDir, "static"),
-								copyPublicDir: true,
-								rollupOptions: { input: getDummyInput() }
-							},
-							consumer: "client"
-						}
-					},
-					builder: {}
-				};
 			},
 			sharedDuringBuild: true
 		},
@@ -524,8 +737,8 @@ function setupEnvs(pluginConfig) {
 			},
 			generateBundle: {
 				order: "post",
-				async handler(_opts, bundle$1) {
-					cleanupDummy(bundle$1);
+				async handler(_opts, bundle$2) {
+					cleanupDummy(bundle$2);
 				}
 			},
 			sharedDuringBuild: true
@@ -541,8 +754,8 @@ function setupEnvs(pluginConfig) {
 			},
 			generateBundle: {
 				order: "post",
-				async handler(_opts, bundle$1) {
-					cleanupDummy(bundle$1);
+				async handler(_opts, bundle$2) {
+					cleanupDummy(bundle$2);
 					this.emitFile({
 						type: "asset",
 						fileName: "config.json",
@@ -557,8 +770,8 @@ function setupEnvs(pluginConfig) {
 			applyToEnvironment(env) {
 				return env.name === "vercel_client";
 			},
-			generateBundle: { async handler(_opts, bundle$1) {
-				cleanupDummy(bundle$1);
+			generateBundle: { async handler(_opts, bundle$2) {
+				cleanupDummy(bundle$2);
 				const topLevelConfig = this.environment.getTopLevelConfig();
 				const clientEnv = topLevelConfig.environments.client;
 				if (clientEnv) try {
@@ -604,9 +817,9 @@ function createVercelEnvironmentOptions(overrides) {
 function getDummyInput() {
 	return { [DUMMY]: `${virtualEntry}:${DUMMY}` };
 }
-function cleanupDummy(bundle$1) {
-	const dummy = Object.keys(bundle$1).find((key) => key.includes("_DUMMY_"));
-	if (dummy) delete bundle$1[dummy];
+function cleanupDummy(bundle$2) {
+	const dummy = Object.keys(bundle$2).find((key) => key.includes("_DUMMY_"));
+	if (dummy) delete bundle$2[dummy];
 }
 
 //#endregion
@@ -618,7 +831,7 @@ function vercel(pluginConfig = {}) {
 		apiPlugin(pluginConfig),
 		...setupEnvs(pluginConfig),
 		...loaderPlugin(pluginConfig),
-		...bundlePlugin(),
+		...pluginConfig?.bundleStrategy === "nf3" ? nf3BundlePlugin() : basicBundlePlugin(),
 		catchAll(),
 		devServer()
 	];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-vercel",
-  "version": "11.0.0-beta.2",
+  "version": "11.0.0-beta.3",
   "type": "module",
   "files": [
     "dist",