nitro 3.0.1-alpha.2 → 3.0.260415-beta

package/dist/_chunks/nitro2.mjs

@@ -1,7 +1,5 @@
-import { N as glob, at as join, st as relative } from "../_build/common.mjs";
+import { M as glob, ct as join, ut as relative } from "../_build/common.mjs";
 import { withBase, withLeadingSlash, withoutTrailingSlash } from "ufo";
-
-//#region src/scan.ts
 const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
 const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
 async function scanAndSyncOptions(nitro) {
@@ -23,9 +21,12 @@ async function scanAndSyncOptions(nitro) {
 async function scanHandlers(nitro) {
 	const middleware = await scanMiddleware(nitro);
 	const handlers = await Promise.all([scanServerRoutes(nitro, nitro.options.apiDir || "api", nitro.options.apiBaseURL || "/api"), scanServerRoutes(nitro, nitro.options.routesDir || "routes")]).then((r) => r.flat());
-	nitro.scannedHandlers = [...middleware, ...handlers.filter((h, index, array) => {
-		return array.findIndex((h2) => h.route === h2.route && h.method === h2.method && h.env === h2.env) === index;
+	const seenHandlers = /* @__PURE__ */ new Set();
+	nitro.scannedHandlers = [...middleware, ...handlers.filter((h) => {
+		const key = `${h.route}\0${h.method}\0${h.env}`;
+		return seenHandlers.has(key) ? false : (seenHandlers.add(key), true);
 	})];
+	nitro.routing.sync();
 	return handlers;
 }
 async function scanMiddleware(nitro) {
@@ -39,7 +40,7 @@ async function scanMiddleware(nitro) {
 }
 async function scanServerRoutes(nitro, dir, prefix = "/") {
 	return (await scanFiles(nitro, dir)).map((file) => {
-		let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}(\w+)]/g, "**:$1").replace(/\[([^/\]]+)]/g, ":$1");
+		let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}([^\]]+)]/g, (_, p) => "**:" + p.replace(/[^\w-]/g, "_")).replace(/\[([^/\]]+)]/g, (_, p) => ":" + p.replace(/[^\w-]/g, "_"));
 		route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
 		const suffixMatch = route.match(suffixRegex);
 		let method;
@@ -96,6 +97,4 @@ async function scanDir(nitro, dir, name) {
 		};
 	}).sort((a, b) => a.path.localeCompare(b.path));
 }
-
-//#endregion
-export { scanHandlers as n, scanAndSyncOptions as t };
+export { scanHandlers as n, scanAndSyncOptions as t };

package/dist/_chunks/nitro3.mjs

@@ -0,0 +1,136 @@
+import { ct as join } from "../_build/common.mjs";
+import { a as findRoute, i as findAllRoutes, n as addRoute, r as createRouter, t as compileRouterToString } from "../_libs/rou3.mjs";
+import { runtimeDir } from "nitro/meta";
+import { hash } from "ohash";
+const isGlobalMiddleware = (h) => !h.method && (!h.route || h.route === "/**");
+function initNitroRouting(nitro) {
+	const envConditions = new Set([
+		nitro.options.dev ? "dev" : "prod",
+		nitro.options.preset,
+		nitro.options.preset === "nitro-prerender" ? "prerender" : void 0
+	].filter(Boolean));
+	const matchesEnv = (h) => {
+		const envs = (Array.isArray(h.env) ? h.env : [h.env]).filter(Boolean);
+		return envs.length === 0 || envs.some((env) => envConditions.has(env));
+	};
+	const routes = new Router(nitro.options.baseURL);
+	const routeRules = new Router(nitro.options.baseURL);
+	const globalMiddleware = [];
+	const routedMiddleware = new Router(nitro.options.baseURL);
+	const sync = () => {
+		routeRules._update(Object.entries(nitro.options.routeRules).map(([route, data]) => ({
+			route,
+			method: "",
+			data: {
+				...data,
+				_route: route
+			}
+		})));
+		const _routes = [
+			...Object.entries(nitro.options.routes).flatMap(([route, handler]) => {
+				if (typeof handler === "string") handler = { handler };
+				return {
+					...handler,
+					route,
+					middleware: false
+				};
+			}),
+			...nitro.options.handlers,
+			...nitro.scannedHandlers
+		].filter((h) => h && !h.middleware && matchesEnv(h));
+		if (nitro.options.serverEntry && nitro.options.serverEntry.handler) _routes.push({
+			route: "/**",
+			lazy: false,
+			format: nitro.options.serverEntry.format,
+			handler: nitro.options.serverEntry.handler
+		});
+		if (nitro.options.renderer?.handler) _routes.push({
+			route: "/**",
+			lazy: true,
+			handler: nitro.options.renderer?.handler
+		});
+		routes._update(_routes.map((h) => ({
+			...h,
+			method: h.method || "",
+			data: handlerWithImportHash(h)
+		})), { merge: true });
+		const _middleware = [...nitro.scannedHandlers, ...nitro.options.handlers].filter((h) => h && h.middleware && matchesEnv(h));
+		if (nitro.options.serveStatic) _middleware.unshift({
+			route: "/**",
+			middleware: true,
+			handler: join(runtimeDir, "internal/static")
+		});
+		globalMiddleware.splice(0, globalMiddleware.length, ..._middleware.filter((h) => isGlobalMiddleware(h)).map((m) => handlerWithImportHash(m)));
+		routedMiddleware._update(_middleware.filter((h) => !isGlobalMiddleware(h)).map((h) => ({
+			...h,
+			method: h.method || "",
+			data: handlerWithImportHash(h)
+		})));
+	};
+	nitro.routing = Object.freeze({
+		sync,
+		routes,
+		routeRules,
+		globalMiddleware,
+		routedMiddleware
+	});
+}
+function handlerWithImportHash(h) {
+	const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler).replace(/-/g, "").slice(0, 6);
+	return {
+		...h,
+		_importHash: id
+	};
+}
+var Router = class {
+	_routes;
+	_router;
+	_compiled;
+	_baseURL;
+	constructor(baseURL) {
+		this._update([]);
+		this._baseURL = baseURL || "";
+		if (this._baseURL.endsWith("/")) this._baseURL = this._baseURL.slice(0, -1);
+	}
+	get routes() {
+		return this._routes;
+	}
+	_update(routes, opts) {
+		this._routes = routes;
+		this._router = createRouter();
+		this._compiled = void 0;
+		for (const route of routes) addRoute(this._router, route.method, this._baseURL + route.route, route.data);
+		if (opts?.merge) mergeCatchAll(this._router);
+	}
+	hasRoutes() {
+		return this._routes.length > 0;
+	}
+	compileToString(opts) {
+		const key = opts ? hash(opts) : "";
+		this._compiled ||= {};
+		if (this._compiled[key]) return this._compiled[key];
+		this._compiled[key] = compileRouterToString(this._router, void 0, opts);
+		if (this.routes.length === 1 && this.routes[0].route === "/**" && this.routes[0].method === "") {
+			const data = (opts?.serialize || JSON.stringify)(this.routes[0].data);
+			let retCode = `{data,params:{"_":p.slice(1)}}`;
+			if (opts?.matchAll) retCode = `[${retCode}]`;
+			this._compiled[key] = `/* @__PURE__ */ (() => {const data=${data};return ((_m, p)=>{return ${retCode};})})()`;
+		}
+		return this._compiled[key];
+	}
+	match(method, path) {
+		return findRoute(this._router, method, path)?.data;
+	}
+	matchAll(method, path) {
+		return findAllRoutes(this._router, method, path).map((route) => route.data);
+	}
+};
+function mergeCatchAll(router) {
+	const handlers = router.root?.wildcard?.methods?.[""];
+	if (!handlers || handlers.length < 2) return;
+	handlers.splice(0, handlers.length, {
+		...handlers[0],
+		data: handlers.map((h) => h.data)
+	});
+}
+export { initNitroRouting as n, Router as t };

package/dist/_chunks/nitro4.mjs

@@ -0,0 +1,127 @@
+import { F as prettyPath, ct as join, dt as resolve, m as getBuildInfo } from "../_build/common.mjs";
+import { n as proxyFetch, r as proxyUpgrade } from "../_libs/httpxy.mjs";
+import consola from "consola";
+import { spawn } from "node:child_process";
+async function startPreview(opts) {
+	const { outputDir, buildInfo } = await getBuildInfo(opts.rootDir);
+	if (!buildInfo) throw new Error("Cannot load nitro build info. Make sure to build first.");
+	const info = [
+		["Build Directory:", prettyPath(outputDir)],
+		["Date:", buildInfo.date && new Date(buildInfo.date).toLocaleString()],
+		["Nitro Version:", buildInfo.versions.nitro],
+		["Nitro Preset:", buildInfo.preset],
+		buildInfo.framework?.name !== "nitro" && ["Framework:", buildInfo.framework?.name + (buildInfo.framework?.version ? ` (v${buildInfo.framework.version})` : "")]
+	].filter((i) => i && i[1]);
+	consola.box({
+		title: " [Build Info] ",
+		message: info.map((i) => `- ${i[0]} ${i[1]}`).join("\n")
+	});
+	const dotEnvEntries = await loadPreviewDotEnv(opts.rootDir);
+	if (dotEnvEntries.length > 0) consola.box({
+		title: " [Environment Variables] ",
+		message: [
+			"Loaded variables from .env files (preview mode only).",
+			"Set platform environment variables for production:",
+			...dotEnvEntries.map(([key, val]) => ` - ${key}`)
+		].join("\n")
+	});
+	if (buildInfo.preset.includes("cloudflare")) {
+		if (!buildInfo.commands?.preview) throw new Error(`No nitro build preview command found for the "${buildInfo.preset}" preset.`);
+		return await runPreviewCommand({
+			command: buildInfo.commands.preview,
+			rootDir: opts.rootDir,
+			env: dotEnvEntries
+		});
+	}
+	let fetchHandler = () => Promise.resolve(new Response("Not Found", { status: 404 }));
+	if (buildInfo.serverEntry) {
+		for (const [key, val] of dotEnvEntries) if (!process.env[key]) process.env[key] = val;
+		const { loadServerEntry } = await import("srvx/loader");
+		const entry = await loadServerEntry({
+			entry: resolve(outputDir, buildInfo.serverEntry),
+			...opts.loader
+		});
+		if (entry.fetch) fetchHandler = entry.fetch;
+	}
+	if (buildInfo.publicDir) {
+		const { serveStatic } = await import("srvx/static");
+		const staticHandler = serveStatic({ dir: join(outputDir, buildInfo.publicDir) });
+		const originalFetchHandler = fetchHandler;
+		fetchHandler = async (req) => {
+			const staticRes = await staticHandler(req, () => void 0);
+			if (staticRes) return staticRes;
+			return originalFetchHandler(req);
+		};
+	}
+	return {
+		fetch: fetchHandler,
+		async close() {}
+	};
+}
+async function loadPreviewDotEnv(root) {
+	const { loadDotenv } = await import("../_libs/_.mjs");
+	const env = await loadDotenv({
+		cwd: root,
+		fileName: [
+			".env.preview",
+			".env.production",
+			".env"
+		]
+	});
+	return Object.entries(env).filter(([_key, val]) => val);
+}
+async function runPreviewCommand(opts) {
+	const [arg0, ...args] = opts.command.split(" ");
+	consola.info(`Spawning preview server...`);
+	consola.info(opts.command);
+	console.log("");
+	const { getRandomPort, waitForPort } = await import("get-port-please");
+	const randomPort = await getRandomPort();
+	const child = spawn(arg0, [
+		...args,
+		"--port",
+		String(randomPort),
+		"--host",
+		"localhost"
+	], {
+		stdio: "inherit",
+		cwd: opts.rootDir,
+		env: {
+			...process.env,
+			...Object.fromEntries(opts.env ?? []),
+			PORT: String(randomPort)
+		}
+	});
+	const killChild = (signal) => {
+		if (child && !child.killed) child.kill(signal);
+	};
+	for (const sig of ["SIGINT", "SIGHUP"]) process.once(sig, () => {
+		killChild(sig);
+	});
+	child.once("exit", (code) => {
+		if (code && code !== 0) consola.error(`[nitro] Preview server exited with code ${code}`);
+	});
+	await waitForPort(randomPort, {
+		retries: 20,
+		delay: 500,
+		host: "localhost"
+	});
+	return {
+		fetch(req) {
+			return proxyFetch({
+				port: randomPort,
+				host: "localhost"
+			}, req);
+		},
+		async upgrade(req, socket, head, opts) {
+			await proxyUpgrade({
+				port: randomPort,
+				host: "localhost"
+			}, req, socket, head, opts);
+		},
+		async close() {
+			killChild("SIGTERM");
+		}
+	};
+}
+export { startPreview as t };

package/dist/_chunks/utils.mjs

@@ -1,13 +1,11 @@
-import { i as __toESM, r as __require, t as __commonJSMin } from "../_common.mjs";
-import { N as glob, V as a, ct as resolve, nt as dirname, p as runParallel, st as relative } from "../_build/common.mjs";
-import fs, { promises } from "node:fs";
+import { r as __require, t as __commonJSMin } from "../_common.mjs";
+import { H as v, M as glob, V as m, at as dirname, dt as resolve, nt as resolveModulePath, p as runParallel, ut as relative } from "../_build/common.mjs";
+import { consola as consola$1 } from "consola";
+import { promises } from "node:fs";
 import { promisify } from "node:util";
 import { colors } from "consola/utils";
 import zlib from "node:zlib";
-import "node:stream";
-
-//#region node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js
-var require_duplexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var Stream = __require("stream");
 	var writeMethods = [
 		"write",
@@ -53,8 +51,8 @@ var require_duplexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 		}
 		function proxyStream(methodName) {
-			reader.on(methodName, reemit$1);
-			function reemit$1() {
+			reader.on(methodName, reemit);
+			function reemit() {
 				var args = slice.call(arguments);
 				args.unshift(methodName);
 				stream.emit.apply(stream, args);
@@ -71,11 +69,7 @@ var require_duplexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			stream.emit("error", err);
 		}
 	}
-}));
-
-//#endregion
-//#region node_modules/.pnpm/gzip-size@7.0.0/node_modules/gzip-size/index.js
-var import_duplexer = /* @__PURE__ */ __toESM(require_duplexer(), 1);
+})))();
 const getOptions = (options) => ({
 	level: 9,
 	...options
@@ -85,9 +79,6 @@ async function gzipSize(input, options) {
 	if (!input) return 0;
 	return (await gzip(input, getOptions(options))).length;
 }
-
-//#endregion
-//#region node_modules/.pnpm/pretty-bytes@7.1.0/node_modules/pretty-bytes/index.js
 const BYTE_UNITS = [
 	"B",
 	"kB",
@@ -200,11 +191,8 @@ function prettyBytes(number, options) {
 	}
 	return applyFixedWidth(result, options.fixedWidth);
 }
-
-//#endregion
-//#region src/utils/fs-tree.ts
 async function generateFSTree(dir, options = {}) {
-	if (a) return;
+	if (v) return;
 	const files = await glob("**/*.*", {
 		cwd: dir,
 		ignore: ["*.map"]
@@ -214,23 +202,23 @@ async function generateFSTree(dir, options = {}) {
 		const path = resolve(dir, file);
 		const src = await promises.readFile(path);
 		const size = src.byteLength;
-		const gzip$1 = options.compressedSizes ? await gzipSize(src) : 0;
+		const gzip = options.compressedSizes ? await gzipSize(src) : 0;
 		items.push({
 			file,
 			path,
 			size,
-			gzip: gzip$1
+			gzip
 		});
 	}, { concurrency: 10 });
-	items.sort((a$1, b) => a$1.path.localeCompare(b.path));
+	items.sort((a, b) => a.path.localeCompare(b.path));
 	let totalSize = 0;
 	let totalGzip = 0;
 	let totalNodeModulesSize = 0;
 	let totalNodeModulesGzip = 0;
 	let treeText = "";
 	for (const [index, item] of items.entries()) {
-		let dir$1 = dirname(item.file);
-		if (dir$1 === ".") dir$1 = "";
+		let dir = dirname(item.file);
+		if (dir === ".") dir = "";
 		const rpath = relative(process.cwd(), item.path);
 		const treeChar = index === items.length - 1 ? "└─" : "├─";
 		if (item.file.includes("node_modules")) {
@@ -249,6 +237,29 @@ async function generateFSTree(dir, options = {}) {
 	treeText += "\n";
 	return treeText;
 }
-
-//#endregion
-export { generateFSTree as t };
+async function importDep(opts, _retry) {
+	const resolved = resolveModulePath(opts.id, {
+		from: [opts.dir, import.meta.url],
+		cache: _retry ? false : true,
+		try: true
+	});
+	if (resolved) return await import(resolved);
+	let shouldInstall;
+	if (_retry || v) shouldInstall = false;
+	else if (m) {
+		consola$1.info(`\`${opts.id}\` is required for ${opts.reason}. Installing automatically in CI environment...`);
+		shouldInstall = true;
+	} else shouldInstall = await consola$1.prompt(`\`${opts.id}\` is required for ${opts.reason}, but it is not installed. Would you like to install it?`, {
+		type: "confirm",
+		default: true,
+		cancel: "undefined"
+	});
+	if (!shouldInstall) throw new Error(`\`${opts.id}\` is not installed. Please add it to your dependencies for ${opts.reason}.`);
+	const start = Date.now();
+	consola$1.start(`Installing \`${opts.id}\` in \`${opts.dir}\`...`);
+	const { addDevDependency } = await import("../_libs/_5.mjs");
+	await addDevDependency(opts.id, { cwd: opts.dir });
+	consola$1.success(`Installed \`${opts.id}\` in ${opts.dir} (${Date.now() - start}ms).`);
+	return importDep(opts, true);
+}
+export { generateFSTree as n, importDep as t };

package/dist/_common.mjs

@@ -1,6 +1,4 @@
 import { createRequire } from "node:module";
-
-//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8,30 +6,22 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, symbols) => {
+var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
 	return to;
 };
@@ -40,6 +30,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/dist/_dev.d.mts

@@ -1,12 +1,9 @@
 import { HTTPHandler } from "h3";
 import { Nitro } from "nitro/types";
-
-//#region src/dev/app.d.ts
 declare class NitroDevApp {
   #private;
   nitro: Nitro;
   fetch: (req: Request) => Response | Promise<Response>;
   constructor(nitro: Nitro, catchAllHandler?: HTTPHandler);
 }
-//#endregion
 export { NitroDevApp as t };