nitro 3.0.260415-beta → 3.0.260522-beta

package/dist/_build/vite.env.mjs

@@ -0,0 +1,177 @@
+import { isAbsolute as isAbsolute$1, resolveModulePath } from "./common.mjs";
+import { runtimeDependencies, runtimeDir } from "nitro/meta";
+import { join, resolve } from "node:path";
+import { RunnerManager, loadRunner } from "env-runner";
+function createNitroEnvironment(ctx) {
+	const isWorkerdRunner = _isWorkerdRunner(ctx);
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: ctx.bundlerConfig.rollupConfig,
+			rolldownOptions: ctx.bundlerConfig.rolldownConfig,
+			minify: ctx.nitro.options.minify,
+			emptyOutDir: false,
+			sourcemap: ctx.nitro.options.sourcemap,
+			commonjsOptions: ctx.nitro.options.commonJS,
+			copyPublicDir: false
+		},
+		resolve: {
+			noExternal: ctx.nitro.options.dev ? isWorkerdRunner ? true : [
+				/^nitro$/,
+				new RegExp(`^(${runtimeDependencies.join("|")})$`),
+				...ctx.bundlerConfig.base.noExternal
+			] : true,
+			conditions: isWorkerdRunner ? [
+				"workerd",
+				"worker",
+				...ctx.nitro.options.exportConditions.filter((c) => c !== "node")
+			] : ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions?.filter((c) => !/browser|wasm|module/.test(c))
+		},
+		define: { "process.env.NODE_ENV": JSON.stringify(ctx.nitro.options.dev ? "development" : "production") },
+		dev: { createEnvironment: async (envName, envConfig) => {
+			const entry = resolve(runtimeDir, "internal/vite/dev-entry.mjs");
+			const { createFetchableDevEnvironment } = await import("./vite.dev.mjs");
+			const env = createFetchableDevEnvironment(envName, envConfig, getEnvRunner(ctx), entry, { preventExternalize: isWorkerdRunner });
+			ctx._transformRequest = (id) => env.transformRequest(id);
+			(ctx._viteEnvs ??= /* @__PURE__ */ new Map()).set(envName, entry);
+			return env;
+		} }
+	};
+}
+function createServiceEnvironment(ctx, name, serviceConfig) {
+	const isWorkerdRunner = _isWorkerdRunner(ctx);
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: {
+				input: { index: serviceConfig.entry },
+				external: [/^nitro(\/|$)/]
+			},
+			minify: ctx.nitro.options.minify,
+			sourcemap: ctx.nitro.options.sourcemap,
+			outDir: join(ctx.nitro.options.buildDir, "vite/services", name),
+			emptyOutDir: true,
+			copyPublicDir: false
+		},
+		resolve: {
+			...isWorkerdRunner ? { noExternal: true } : {},
+			conditions: isWorkerdRunner ? [
+				"workerd",
+				"worker",
+				...ctx.nitro.options.exportConditions.filter((c) => c !== "node")
+			] : ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions?.filter((c) => !/browser|wasm|module/.test(c))
+		},
+		dev: { createEnvironment: async (envName, envConfig) => {
+			const entry = tryResolve(serviceConfig.entry);
+			(ctx._viteEnvs ??= /* @__PURE__ */ new Map()).set(envName, entry);
+			const { createFetchableDevEnvironment } = await import("./vite.dev.mjs");
+			return createFetchableDevEnvironment(envName, envConfig, getEnvRunner(ctx), entry, { preventExternalize: isWorkerdRunner });
+		} }
+	};
+}
+function createServiceEnvironments(ctx) {
+	return Object.fromEntries(Object.entries(ctx.services).map(([name, config]) => [name, createServiceEnvironment(ctx, name, config)]));
+}
+async function initEnvRunner(ctx) {
+	if (ctx._envRunner) return ctx._envRunner;
+	if (!ctx._initPromise) ctx._initPromise = (async () => {
+		const manager = new RunnerManager();
+		let _retries = 0;
+		manager.onClose((_runner, cause) => {
+			if (_retries++ < 3) {
+				ctx.nitro.logger.info("Restarting env runner...", cause ? `Cause: ${cause}` : "");
+				_loadRunner(ctx, manager);
+			} else ctx.nitro.logger.error("Env runner failed after 3 retries.", cause ? `Last cause: ${cause}` : "");
+		});
+		manager.onReady(() => {
+			_retries = 0;
+			if (ctx._viteEnvs) for (const [name, entry] of ctx._viteEnvs) manager.sendMessage({
+				type: "custom",
+				event: "nitro:vite-env",
+				data: {
+					name,
+					entry
+				}
+			});
+		});
+		await _loadRunner(ctx, manager);
+		ctx._envRunner = manager;
+		return manager;
+	})();
+	return await ctx._initPromise;
+}
+function getEnvRunner(ctx) {
+	if (!ctx._envRunner) throw new Error("Env runner not initialized. Call initEnvRunner() first.");
+	return ctx._envRunner;
+}
+async function _loadRunner(ctx, manager) {
+	const runnerName = ctx.nitro.options.devServer.runner || process.env.NITRO_DEV_RUNNER || "node-worker";
+	const entry = resolve(runtimeDir, "internal/vite/dev-worker.mjs");
+	let runner;
+	if (runnerName === "miniflare") {
+		const { MiniflareEnvRunner } = await import("env-runner/runners/miniflare");
+		runner = new MiniflareEnvRunner({
+			name: "nitro-vite",
+			data: { entry }
+		});
+	} else runner = await loadRunner(runnerName, {
+		name: "nitro-vite",
+		data: { entry }
+	});
+	await manager.reload(runner);
+}
+const NITRO_PROXY_PREFIX = "\0nitro-env-proxy:";
+function nitroServiceProxy() {
+	return {
+		name: "nitro:service-proxy",
+		enforce: "pre",
+		applyToEnvironment: (env) => env.name !== "nitro" && env.config.consumer === "server",
+		apply: (_config, configEnv) => configEnv.command === "serve",
+		resolveId: {
+			filter: { id: /^nitro(\/|$)/ },
+			handler(id) {
+				if (id === "nitro" || id.startsWith("nitro/")) return {
+					id: NITRO_PROXY_PREFIX + id,
+					moduleSideEffects: false
+				};
+			}
+		},
+		load: {
+			filter: { id: /^\0nitro-env-proxy:/ },
+			handler(id) {
+				if (!id.startsWith(NITRO_PROXY_PREFIX)) return;
+				const originalId = id.slice(17);
+				return {
+					code: [
+						`const _mod = await globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__("nitro", ${JSON.stringify(originalId)});`,
+						`__vite_ssr_exportAll__(_mod);`,
+						`export default _mod.default;`
+					].join("\n"),
+					map: null
+				};
+			}
+		}
+	};
+}
+function _isWorkerdRunner(ctx) {
+	return (ctx.nitro.options.devServer.runner || process.env.NITRO_DEV_RUNNER || "node-worker") === "miniflare";
+}
+function tryResolve(id) {
+	if (/^[~#/\0]/.test(id) || isAbsolute$1(id)) return id;
+	return resolveModulePath(id, {
+		suffixes: ["", "/index"],
+		extensions: [
+			"",
+			".ts",
+			".mjs",
+			".cjs",
+			".js",
+			".mts",
+			".cts"
+		],
+		try: true
+	}) || id;
+}
+export { createNitroEnvironment, createServiceEnvironment, createServiceEnvironments, getEnvRunner, initEnvRunner, nitroServiceProxy };

package/dist/_chunks/nitro.mjs

@@ -1,14 +1,11 @@
-import { i as loadConfig, s as watchConfig } from "../_libs/c12+rc9.mjs";
-import { A as src_default, F as prettyPath, H as v, I as resolveNitroPath, K as findWorkspaceDir, L as writeFile$1, O as scanUnprefixedPublicAssets, ct as join, dt as resolve, j as build, k as compressPublicAssets, nt as resolveModulePath, p as runParallel, rt as resolveModuleURL, ut as relative, z as _ } from "../_build/common.mjs";
-import { n as resolveCompatibilityDates, r as resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
-import { t as klona } from "../_libs/klona.mjs";
-import { t as escapeStringRegexp } from "../_libs/escape-string-regexp.mjs";
-import { n as parse, t as TSConfckCache } from "../_libs/tsconfck.mjs";
-import { n as scanHandlers, t as scanAndSyncOptions } from "./nitro2.mjs";
-import { i as findAllRoutes, n as addRoute, r as createRouter } from "../_libs/rou3.mjs";
-import { n as initNitroRouting } from "./nitro3.mjs";
+import { loadConfig, watchConfig } from "../_libs/c12+rc9.mjs";
+import { _, build, compressPublicAssets, escapeRegExp, findWorkspaceDir, glob, join, prettyPath, relative, resolve, resolveModulePath, resolveModuleURL, resolveNitroPath, runParallel, scanUnprefixedPublicAssets, src_default, v, writeFile as writeFile$1 } from "../_build/common.mjs";
+import { resolveCompatibilityDates, resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
+import { klona } from "../_libs/klona.mjs";
+import { TSConfckCache, parse } from "../_libs/tsconfck.mjs";
+import { addRoute, compileRouterToString, createRouter, findAllRoutes, findRoute } from "../_libs/rou3.mjs";
 import "../_dev.mjs";
-import { n as z, t as P } from "../_libs/ultrahtml.mjs";
+import { P, z } from "../_libs/ultrahtml.mjs";
 import { createRequire } from "node:module";
 import consola, { consola as consola$1 } from "consola";
 import { Hookable, createDebugger } from "hookable";
@@ -19,6 +16,7 @@ import { pathToFileURL } from "node:url";
 import { defu } from "defu";
 import { joinURL, parseURL, withBase, withLeadingSlash, withQuery, withTrailingSlash, withoutBase, withoutTrailingSlash } from "ufo";
 import { colors } from "consola/utils";
+import { hash } from "ohash";
 import { toRequest } from "h3";
 import http from "node:http";
 const NitroDefaults = {
@@ -165,7 +163,7 @@ async function resolveImportsOptions(options) {
 		options.imports.exclude.push(/[/\\]\.git[/\\]/);
 		options.imports.exclude.push(options.buildDir);
 		const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
-		options.imports.exclude.push(scanDirsInNodeModules.length > 0 ? new RegExp(`node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeStringRegexp(dir)).join("|")})`) : /[/\\]node_modules[/\\]/);
+		options.imports.exclude.push(scanDirsInNodeModules.length > 0 ? new RegExp(`node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRegExp(dir)).join("|")})`) : /[/\\]node_modules[/\\]/);
 	}
 }
 async function resolveOpenAPIOptions(options) {
@@ -475,7 +473,7 @@ function isPkgInstalled(pkg, root) {
 	}
 }
 async function installPkg(pkg, root) {
-	const { addDevDependency } = await import("../_libs/_5.mjs");
+	const { addDevDependency } = await import("../_libs/nypm+tinyexec.mjs").then((n) => n.dist_exports);
 	return addDevDependency(pkg, { cwd: root });
 }
 function hasNitroViteConfig(options) {
@@ -497,6 +495,7 @@ async function resolveTracingOptions(options) {
 	options.tracingChannel = {
 		srvx: true,
 		h3: true,
+		unstorage: true,
 		...typeof options.tracingChannel === "object" ? options.tracingChannel : {}
 	};
 	options.plugins = options.plugins || [];
@@ -626,6 +625,234 @@ async function _resolveNitroModule(mod, nitroOptions) {
 		...mod
 	};
 }
+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) {
+	const scannedPlugins = await scanPlugins(nitro);
+	for (const plugin of scannedPlugins) if (!nitro.options.plugins.includes(plugin)) nitro.options.plugins.push(plugin);
+	if (nitro.options.experimental.tasks) {
+		const scannedTasks = await scanTasks(nitro);
+		for (const scannedTask of scannedTasks) if (scannedTask.name in nitro.options.tasks) {
+			if (!nitro.options.tasks[scannedTask.name].handler) nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
+		} else nitro.options.tasks[scannedTask.name] = {
+			handler: scannedTask.handler,
+			description: ""
+		};
+	}
+	const scannedModules = await scanModules(nitro);
+	nitro.options.modules = nitro.options.modules || [];
+	for (const modPath of scannedModules) if (!nitro.options.modules.includes(modPath)) nitro.options.modules.push(modPath);
+}
+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());
+	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) {
+	return (await scanFiles(nitro, "middleware")).map((file) => {
+		return {
+			route: "/**",
+			middleware: true,
+			handler: file.fullPath
+		};
+	});
+}
+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}([^\]]+)]/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;
+		let env;
+		if (suffixMatch?.index && suffixMatch?.index >= 0) {
+			route = route.slice(0, suffixMatch.index);
+			method = suffixMatch.groups?.method;
+			env = suffixMatch.groups?.env;
+		}
+		route = route.replace(/\/index$/, "") || "/";
+		return {
+			handler: file.fullPath,
+			lazy: true,
+			middleware: false,
+			route,
+			method,
+			env
+		};
+	});
+}
+async function scanPlugins(nitro) {
+	return (await scanFiles(nitro, "plugins")).map((f) => f.fullPath);
+}
+async function scanTasks(nitro) {
+	return (await scanFiles(nitro, "tasks")).map((f) => {
+		return {
+			name: f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":"),
+			handler: f.fullPath
+		};
+	});
+}
+async function scanModules(nitro) {
+	return (await scanFiles(nitro, "modules")).map((f) => f.fullPath);
+}
+async function scanFiles(nitro, name) {
+	return await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))).then((r) => r.flat());
+}
+async function scanDir(nitro, dir, name) {
+	return (await glob(join(name, GLOB_SCAN_PATTERN), {
+		cwd: dir,
+		dot: true,
+		ignore: nitro.options.ignore,
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
+			return [];
+		}
+		throw error;
+	})).map((fullPath) => {
+		return {
+			fullPath,
+			path: relative(join(dir, name), fullPath)
+		};
+	}).sort((a, b) => a.path.localeCompare(b.path));
+}
+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)
+	});
+}
 const nitroInstances = globalThis.__nitro_instances__ ||= [];
 const globalKey = "__nitro_builder__";
 function registerNitroInstance(nitro) {
@@ -675,7 +902,7 @@ async function createNitro(config = {}, opts = {}) {
 	nitro.hooks.addHooks(nitro.options.hooks);
 	await installModules(nitro);
 	if (nitro.options.imports) {
-		const { createUnimport } = await import("../_build/common.mjs").then((n) => n.v);
+		const { createUnimport } = await import("../_build/common.mjs").then((n) => n.dist_exports);
 		nitro.unimport = createUnimport(nitro.options.imports);
 		await nitro.unimport.init();
 		nitro.options.virtual["#imports"] = () => nitro.unimport?.toExports() || "";
@@ -963,4 +1190,4 @@ function _pidIsRunning(pid) {
 		return false;
 	}
 }
-export { loadOptions as a, createNitro as i, runTask as n, prerender as r, listTasks as t };
+export { Router, createNitro, listTasks, loadOptions, prerender, runTask, scanHandlers };