@ubean/routing 0.1.2 → 0.1.4

package/dist/index.js

@@ -0,0 +1,1057 @@
+import { GLOB_LAYOUT_PATTERN, GLOB_SCAN_PATTERN, GLOB_VUE_PATTERN, HTTP_METHODS } from "./types.js";
+import { readFile } from "node:fs/promises";
+import { filePathToRoute, filePathToRoute as filePathToRoute$1, stripRouteGroups } from "@ubean/utils";
+import { consola } from "consola";
+import { basename, dirname, extname, isAbsolute, join, relative } from "pathe";
+import { glob } from "tinyglobby";
+import { pascalCase } from "scule";
+import { addRoute, createRouter, findRoute } from "rou3";
+//#region src/define-page.ts
+function extractScriptContent(code) {
+	if (!code.includes("<script")) return code;
+	let scriptContent = "";
+	const scriptRegex = /<script([^>]*)>([\s\S]*?)<\/script>/g;
+	let match;
+	while ((match = scriptRegex.exec(code)) !== null) {
+		const attrs = match[1] || "";
+		const content = match[2] || "";
+		if (attrs.includes("setup")) return content;
+		scriptContent += `${content}\n`;
+	}
+	return scriptContent || null;
+}
+function findBalancedCall(code, funcName) {
+	const callPattern = new RegExp(`\\b${funcName}\\s*\\(`, "g");
+	let match;
+	while ((match = callPattern.exec(code)) !== null) {
+		const startIdx = match.index + match[0].length;
+		let depth = 1;
+		let i = startIdx;
+		let inString = null;
+		let escaped = false;
+		while (i < code.length && depth > 0) {
+			const ch = code[i];
+			if (escaped) {
+				escaped = false;
+				i++;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				i++;
+				continue;
+			}
+			if (inString) {
+				if (ch === inString) inString = null;
+				i++;
+				continue;
+			}
+			if (ch === "\"" || ch === "'" || ch === "`") {
+				inString = ch;
+				i++;
+				continue;
+			}
+			if (ch === "(" || ch === "{" || ch === "[") depth++;
+			else if (ch === ")" || ch === "}" || ch === "]") {
+				depth--;
+				if (depth === 0 && ch === ")") return code.slice(startIdx, i);
+			}
+			i++;
+		}
+	}
+	return null;
+}
+function skipWhitespace(code, pos) {
+	while (pos < code.length && /\s/.test(code[pos])) pos++;
+	return pos;
+}
+function parseStringValue(code, pos) {
+	const quote = code[pos];
+	if (quote !== "\"" && quote !== "'" && quote !== "`") return null;
+	pos++;
+	let value = "";
+	let escaped = false;
+	while (pos < code.length) {
+		const ch = code[pos];
+		if (escaped) {
+			value += ch;
+			escaped = false;
+			pos++;
+			continue;
+		}
+		if (ch === "\\") {
+			escaped = true;
+			pos++;
+			continue;
+		}
+		if (ch === quote) if (quote === "`") {
+			value += ch;
+			pos++;
+			if (pos >= code.length || code[pos] !== "`") {
+				pos--;
+				break;
+			}
+		} else {
+			pos++;
+			break;
+		}
+		value += ch;
+		pos++;
+	}
+	if (quote !== "`") return {
+		value,
+		pos
+	};
+	return {
+		value,
+		pos
+	};
+}
+function parseIdentifier(code, pos) {
+	const start = pos;
+	while (pos < code.length && /[\w$]/.test(code[pos])) pos++;
+	if (pos === start) return null;
+	return {
+		name: code.slice(start, pos),
+		pos
+	};
+}
+function parseValue(code, pos) {
+	pos = skipWhitespace(code, pos);
+	if (pos >= code.length) return null;
+	const ch = code[pos];
+	if (ch === "\"" || ch === "'" || ch === "`") {
+		const str = parseStringValue(code, pos);
+		if (str) return {
+			value: str.value,
+			pos: str.pos
+		};
+		return null;
+	}
+	if (ch === "{") return parseObjectValue(code, pos);
+	if (ch === "[") return parseArrayValue(code, pos);
+	if (ch === "t" && code.slice(pos, pos + 4) === "true") return {
+		value: true,
+		pos: pos + 4
+	};
+	if (ch === "f" && code.slice(pos, pos + 5) === "false") return {
+		value: false,
+		pos: pos + 5
+	};
+	if (ch === "n" && code.slice(pos, pos + 4) === "null") return {
+		value: null,
+		pos: pos + 4
+	};
+	const numMatch = code.slice(pos).match(/^-?\d+\.?\d*(?:[eE][+-]?\d+)?/);
+	if (numMatch) return {
+		value: Number(numMatch[0]),
+		pos: pos + numMatch[0].length
+	};
+	const ident = parseIdentifier(code, pos);
+	if (ident) return {
+		value: ident.name,
+		pos: ident.pos
+	};
+	return null;
+}
+function parseObjectValue(code, pos) {
+	if (code[pos] !== "{") return null;
+	pos++;
+	const result = {};
+	pos = skipWhitespace(code, pos);
+	if (code[pos] === "}") return {
+		value: result,
+		pos: pos + 1
+	};
+	while (pos < code.length) {
+		pos = skipWhitespace(code, pos);
+		let key = null;
+		if (code[pos] === "\"" || code[pos] === "'") {
+			const keyStr = parseStringValue(code, pos);
+			if (keyStr) {
+				key = keyStr.value;
+				pos = keyStr.pos;
+			}
+		} else {
+			const ident = parseIdentifier(code, pos);
+			if (ident) {
+				key = ident.name;
+				pos = ident.pos;
+			}
+		}
+		if (!key) break;
+		pos = skipWhitespace(code, pos);
+		if (code[pos] !== ":") break;
+		pos++;
+		pos = skipWhitespace(code, pos);
+		const val = parseValue(code, pos);
+		if (val) {
+			result[key] = val.value;
+			pos = val.pos;
+		}
+		pos = skipWhitespace(code, pos);
+		if (code[pos] === ",") {
+			pos++;
+			continue;
+		}
+		if (code[pos] === "}") {
+			pos++;
+			break;
+		}
+		break;
+	}
+	return {
+		value: result,
+		pos
+	};
+}
+function parseArrayValue(code, pos) {
+	if (code[pos] !== "[") return null;
+	pos++;
+	const result = [];
+	pos = skipWhitespace(code, pos);
+	if (code[pos] === "]") return {
+		value: result,
+		pos: pos + 1
+	};
+	while (pos < code.length) {
+		pos = skipWhitespace(code, pos);
+		const val = parseValue(code, pos);
+		if (val) {
+			result.push(val.value);
+			pos = val.pos;
+		}
+		pos = skipWhitespace(code, pos);
+		if (code[pos] === ",") {
+			pos++;
+			continue;
+		}
+		if (code[pos] === "]") {
+			pos++;
+			break;
+		}
+		break;
+	}
+	return {
+		value: result,
+		pos
+	};
+}
+function parseObjectLiteral(code) {
+	const start = skipWhitespace(code, 0);
+	if (code[start] !== "{") return {};
+	const parsed = parseObjectValue(code, start);
+	if (parsed) return parsed.value;
+	const result = {};
+	const simpleRegex = /(\w+)\s*:\s*(['"`])((?:(?!\2)[^\\]|\\.)*)\2/g;
+	let m;
+	while ((m = simpleRegex.exec(code)) !== null) result[m[1]] = m[3];
+	return result;
+}
+function extractAndParseCall(code, funcName) {
+	const argStr = findBalancedCall(code, funcName);
+	if (!argStr) return null;
+	const trimmed = argStr.trim();
+	if (!trimmed.startsWith("{")) return null;
+	return parseObjectLiteral(trimmed);
+}
+function extractDefinePageFromCode(code) {
+	const scriptContent = extractScriptContent(code);
+	if (!scriptContent) return null;
+	const parsed = extractAndParseCall(scriptContent, "definePage");
+	if (!parsed) return null;
+	const result = {};
+	if (typeof parsed.name === "string") result.name = parsed.name;
+	if (typeof parsed.path === "string") result.path = parsed.path;
+	if (parsed.layout === false || typeof parsed.layout === "string" && parsed.layout !== "default") result.layout = parsed.layout;
+	if (typeof parsed.reuse === "string") result.reuse = parsed.reuse;
+	if (parsed.meta && typeof parsed.meta === "object") result.meta = parsed.meta;
+	if (typeof parsed.requiresAuth === "boolean") result.requiresAuth = parsed.requiresAuth;
+	if (typeof parsed.cache === "boolean") result.cache = parsed.cache;
+	if (typeof parsed.middleware === "string") result.middleware = parsed.middleware;
+	else if (Array.isArray(parsed.middleware)) result.middleware = parsed.middleware.filter((m) => typeof m === "string");
+	return result;
+}
+function extractDefineMetaFromCode(code) {
+	const scriptContent = extractScriptContent(code);
+	if (!scriptContent) return null;
+	const parsed = extractAndParseCall(scriptContent, "defineHandlerMeta");
+	if (!parsed) return null;
+	const result = {};
+	if (typeof parsed.requiresAuth === "boolean") result.requiresAuth = parsed.requiresAuth;
+	if (parsed.meta && typeof parsed.meta === "object") result.meta = parsed.meta;
+	else {
+		const knownKeys = /* @__PURE__ */ new Set(["requiresAuth", "meta"]);
+		const extra = {};
+		for (const [key, val] of Object.entries(parsed)) if (!knownKeys.has(key)) extra[key] = val;
+		if (Object.keys(extra).length > 0) result.meta = extra;
+	}
+	return result;
+}
+async function extractDefinePage(filePath) {
+	return extractDefinePageFromCode(await readFile(filePath, "utf-8"));
+}
+async function extractDefineMeta(filePath) {
+	return extractDefineMetaFromCode(await readFile(filePath, "utf-8"));
+}
+//#endregion
+//#region src/detect-exports.ts
+const EXPORT_NAMED_REGEX = /export\s+(?:async\s+)?(?:function\s+|const\s+|let\s+|var\s+)?(\w+)/g;
+const EXPORT_LIST_REGEX = /export\s*\{([^}]+)\}/g;
+const EXPORT_DEFINE_META_REGEX = /defineHandlerMeta\s*\(/;
+const EXPORT_CONST_META_REGEX = /export\s+const\s+meta\s*=\s*(\{[\s\S]*?\})(?:\s*;|\s*$)/m;
+const META_REQUIRES_AUTH_REGEX = /requiresAuth\s*:\s*(true|false)/;
+async function detectHttpExports(filePath) {
+	return detectHttpExportsFromCode(await readFile(filePath, "utf-8"));
+}
+function detectHttpExportsFromCode(code) {
+	const exports = /* @__PURE__ */ new Set();
+	const httpMethods = [];
+	let match;
+	EXPORT_NAMED_REGEX.lastIndex = 0;
+	while ((match = EXPORT_NAMED_REGEX.exec(code)) !== null) {
+		const name = match[1];
+		exports.add(name);
+		const lower = name.toLowerCase();
+		if (HTTP_METHODS.includes(name) && !httpMethods.includes(lower)) httpMethods.push(lower);
+	}
+	EXPORT_LIST_REGEX.lastIndex = 0;
+	while ((match = EXPORT_LIST_REGEX.exec(code)) !== null) {
+		const list = match[1];
+		for (const item of list.split(",")) {
+			const name = item.trim().split(/\s+as\s+/).pop()?.trim();
+			if (name) {
+				exports.add(name);
+				const upper = name.toUpperCase();
+				const lower = name.toLowerCase();
+				if (HTTP_METHODS.includes(upper) && !httpMethods.includes(lower)) httpMethods.push(lower);
+			}
+		}
+	}
+	const hasDefineMeta = EXPORT_DEFINE_META_REGEX.test(code);
+	const fileMeta = extractFileMeta(code);
+	const hasMeta = hasDefineMeta || !!fileMeta;
+	return {
+		exports: [...exports],
+		httpMethods,
+		hasMeta,
+		fileMeta
+	};
+}
+function extractFileMeta(code) {
+	const match = code.match(EXPORT_CONST_META_REGEX);
+	if (!match) return void 0;
+	const metaBlock = match[1];
+	const meta = {};
+	const requiresAuthMatch = metaBlock.match(META_REQUIRES_AUTH_REGEX);
+	if (requiresAuthMatch) meta.requiresAuth = requiresAuthMatch[1] === "true";
+	return Object.keys(meta).length > 0 ? meta : void 0;
+}
+//#endregion
+//#region src/scan.ts
+const logger = consola.withTag("ubean-routing");
+let _frontmatterParser;
+async function getFrontmatterParser() {
+	if (_frontmatterParser !== void 0) return _frontmatterParser;
+	try {
+		_frontmatterParser = (await import("@ubean/markdown")).parseFrontmatter;
+	} catch {
+		logger.warn("@ubean/markdown is not installed. Markdown frontmatter parsing will be skipped. Install it as a dependency to enable frontmatter-based page metadata.");
+		_frontmatterParser = null;
+	}
+	return _frontmatterParser;
+}
+const DEFAULT_DIRS = {
+	routes: "routes",
+	middleware: "middleware",
+	pages: "pages",
+	layouts: "layouts",
+	plugins: "plugins",
+	crons: "crons",
+	queues: "queues",
+	locales: "locales"
+};
+/**
+* Normalize a `string | string[]` dir entry into `string[]`. Falsy values
+* fall back to the provided default so callers always receive a non-empty
+* list. Empty arrays are also replaced with the default to keep downstream
+* globbing simple.
+*/
+function normalizeDirs(value, fallback) {
+	if (value === void 0 || value === null || value === "") return [fallback];
+	if (Array.isArray(value)) {
+		const filtered = value.filter((d) => typeof d === "string" && d.length > 0);
+		return filtered.length > 0 ? filtered : [fallback];
+	}
+	return [value];
+}
+function splitOrderPrefix(name) {
+	const match = name.match(/^(\d+)\.(.+)$/);
+	if (match) return {
+		order: Number(match[1]),
+		cleanName: match[2]
+	};
+	return {
+		order: 0,
+		cleanName: name
+	};
+}
+function toPosixPath(p) {
+	return p.replace(/\\/g, "/");
+}
+async function scanProject(options) {
+	const dirs = {
+		...DEFAULT_DIRS,
+		...options.dirs
+	};
+	const ignore = options.ignore || [
+		"**/*.test.*",
+		"**/*.spec.*",
+		"**/_*",
+		"**/*.d.ts"
+	];
+	const srcDir = isAbsolute(options.srcDir) ? options.srcDir : join(options.cwd, options.srcDir);
+	const [apiRoutes, middlewares, pages, layouts, plugins, crons, queues, locales, appEntry, serverEntry] = await Promise.all([
+		scanApiRoutes(srcDir, dirs.routes, ignore),
+		scanMiddlewares(srcDir, dirs.middleware, ignore),
+		scanPages(srcDir, dirs.pages, ignore),
+		scanLayouts(srcDir, dirs.layouts, ignore),
+		scanPlugins(srcDir, dirs.plugins, ignore),
+		scanCrons(srcDir, dirs.crons, ignore),
+		scanQueues(srcDir, dirs.queues, ignore),
+		scanLocales(srcDir, dirs.locales, ignore),
+		scanAppEntry(srcDir),
+		scanServerEntry(srcDir)
+	]);
+	const regularPageNames = new Set(pages.filter((p) => !p.isReuse).map((p) => p.name));
+	for (const page of pages) if (page.isReuse && page.reuseTarget && !regularPageNames.has(page.reuseTarget)) logger.warn(`Reuse page "${page.name}" references target "${page.reuseTarget}" which does not exist. Available page targets: ${[...regularPageNames].join(", ") || "(none)"}`);
+	return {
+		apiRoutes,
+		middlewares,
+		pages,
+		layouts,
+		plugins,
+		crons,
+		queues,
+		locales,
+		defaultLocale: locales.find((l) => l.isDefault)?.code || locales[0]?.code,
+		appEntry,
+		serverEntry
+	};
+}
+async function scanApiRoutes(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "routes");
+	const routes = [];
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_SCAN_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/*.vue",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const base = basename(relativePath, extname(relativePath));
+			const dirPart = dirname(relativePath) === "." ? "" : dirname(relativePath);
+			const parsed = filePathToRoute$1(dirPart ? `${dirPart}/${base}` : base);
+			const detected = await detectHttpExports(fullPath).catch(() => ({
+				exports: [],
+				httpMethods: [],
+				hasMeta: false,
+				fileMeta: void 0
+			}));
+			const methods = detected.httpMethods.length > 0 ? detected.httpMethods : parsed.method ? [parsed.method.toLowerCase()] : [];
+			for (const method of methods.length > 0 ? methods : HTTP_METHODS.map((m) => m.toLowerCase())) routes.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				route: parsed.route,
+				method,
+				env: parsed.env,
+				exports: detected.exports,
+				hasMeta: detected.hasMeta,
+				fileMeta: detected.fileMeta
+			});
+		}
+	}
+	return routes;
+}
+async function scanMiddlewares(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "middleware");
+	const results = [];
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_SCAN_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/*.vue",
+				"**/index.*",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const { order, cleanName } = splitOrderPrefix(basename(relativePath, extname(relativePath)));
+			results.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				order,
+				global: cleanName === "global" || cleanName.startsWith("global.")
+			});
+		}
+	}
+	return results;
+}
+async function scanPages(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "pages");
+	const pages = [];
+	const seenFullPaths = /* @__PURE__ */ new Set();
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_VUE_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/components/**",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			if (seenFullPaths.has(fullPath)) continue;
+			seenFullPaths.add(fullPath);
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const ext = extname(relativePath);
+			const base = basename(relativePath, ext);
+			if (base.startsWith("_")) continue;
+			const isMarkdown = ext === ".md" || ext === ".mdx";
+			const isReuse = !isMarkdown && base.endsWith(".reuse");
+			const pageBase = isReuse ? base.slice(0, -6) : base;
+			const dirPart = dirname(relativePath) === "." ? "" : dirname(relativePath);
+			const { route } = filePathToRoute$1(dirPart ? `${dirPart}/${pageBase}` : pageBase);
+			const name = routeToName(route);
+			let pageMeta = null;
+			let frontmatter;
+			if (isMarkdown) try {
+				const content = await readFile(fullPath, "utf-8");
+				const parser = await getFrontmatterParser();
+				if (parser) {
+					frontmatter = parser(content).data;
+					pageMeta = {
+						name: frontmatter?.name || name,
+						path: frontmatter?.path || route,
+						layout: frontmatter?.layout,
+						cache: frontmatter?.cache,
+						head: buildMarkdownHead(frontmatter)
+					};
+				} else pageMeta = {
+					name,
+					path: route
+				};
+			} catch {
+				pageMeta = null;
+			}
+			else pageMeta = await extractDefinePage(fullPath).catch(() => null);
+			pages.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				name: pageMeta?.name || name,
+				route: pageMeta?.path || route,
+				path: pageMeta?.path || route,
+				layout: pageMeta?.layout,
+				cache: pageMeta?.cache,
+				isReuse,
+				isMarkdown,
+				reuseTarget: pageMeta?.reuse,
+				pageMeta: pageMeta || void 0,
+				frontmatter
+			});
+		}
+	}
+	return pages;
+}
+async function scanLayouts(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "layouts");
+	const results = [];
+	const seenFullPaths = /* @__PURE__ */ new Set();
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_LAYOUT_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [...ignore, "**/_*"],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			if (seenFullPaths.has(fullPath)) continue;
+			seenFullPaths.add(fullPath);
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const base = basename(relativePath, extname(relativePath));
+			const dirPart = dirname(relativePath) === "." ? "" : dirname(relativePath);
+			const layoutBase = base === "index" ? dirPart : dirPart ? `${dirPart}/${base}` : base;
+			const isDefault = base === "default" || base === "index" && !dirPart;
+			const name = layoutBase || "default";
+			results.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				name,
+				path: toPosixPath(relativePath),
+				isDefault
+			});
+		}
+	}
+	return results;
+}
+async function scanPlugins(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "plugins");
+	const results = [];
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_SCAN_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/*.vue",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const { order } = splitOrderPrefix(basename(relativePath, extname(relativePath)));
+			results.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				order
+			});
+		}
+	}
+	return results;
+}
+const APP_EXTENSIONS = [
+	"ts",
+	"js",
+	"mjs",
+	"mts"
+];
+async function scanCrons(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "crons");
+	const results = [];
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_SCAN_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/*.vue",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const { cleanName } = splitOrderPrefix(basename(relativePath, extname(relativePath)));
+			results.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				name: cleanName
+			});
+		}
+	}
+	return results;
+}
+async function scanQueues(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "queues");
+	const results = [];
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(GLOB_SCAN_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/*.vue",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const { cleanName } = splitOrderPrefix(basename(relativePath, extname(relativePath)));
+			results.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				name: cleanName
+			});
+		}
+	}
+	return results;
+}
+const LOCALE_GLOB_PATTERN = "**/*.{json,json5,yaml,yml,js,mjs,cjs,ts,mts,cts}";
+function parseSimpleYaml(content) {
+	const result = {};
+	const lines = content.split("\n");
+	let currentObj = result;
+	const stack = [];
+	for (const line of lines) {
+		const trimmed = line.replace(/#.*$/, "").trimEnd();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const indent = line.length - line.trimStart().length;
+		const match = trimmed.match(/^([\w.-]+)\s*:\s*(.*)$/);
+		if (!match) continue;
+		const [, key, value] = match;
+		while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop();
+		currentObj = stack.length > 0 ? stack[stack.length - 1].obj : result;
+		if (value === "" || value === void 0) {
+			const newObj = {};
+			currentObj[key] = newObj;
+			stack.push({
+				obj: newObj,
+				indent
+			});
+			currentObj = newObj;
+		} else {
+			let parsed = value;
+			if (value === "true") parsed = true;
+			else if (value === "false") parsed = false;
+			else if (value === "null") parsed = null;
+			else if (/^-?\d+$/.test(value)) parsed = Number.parseInt(value, 10);
+			else if (/^-?\d+\.\d+$/.test(value)) parsed = Number.parseFloat(value);
+			else if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) parsed = value.slice(1, -1);
+			currentObj[key] = parsed;
+		}
+	}
+	return result;
+}
+async function loadLocaleFile(fullPath, ext) {
+	const extract = (data) => {
+		const isWrapper = (typeof data.name === "string" || data.dir === "ltr" || data.dir === "rtl" || typeof data.isDefault === "boolean") && typeof data.messages === "object" && data.messages !== null;
+		return {
+			messages: isWrapper ? data.messages : data,
+			meta: isWrapper ? {
+				name: data.name,
+				dir: data.dir,
+				isDefault: data.isDefault
+			} : void 0
+		};
+	};
+	if (ext === ".json" || ext === ".json5") {
+		const content = await readFile(fullPath, "utf-8");
+		return extract(JSON.parse(content));
+	}
+	if (ext === ".yaml" || ext === ".yml") return extract(parseSimpleYaml(await readFile(fullPath, "utf-8")));
+	if (ext === ".js" || ext === ".mjs" || ext === ".cjs" || ext === ".ts" || ext === ".mts" || ext === ".cts") {
+		const mod = await import(
+			/* @vite-ignore */
+			fullPath
+).catch(() => null);
+		if (mod) return extract(mod.default || mod);
+	}
+	return { messages: {} };
+}
+async function scanLocales(srcDir, dirName, ignore) {
+	const dirNames = normalizeDirs(dirName, "locales");
+	const locales = [];
+	const seenFullPaths = /* @__PURE__ */ new Set();
+	for (const single of dirNames) {
+		const dir = join(srcDir, single);
+		const files = await glob(LOCALE_GLOB_PATTERN, {
+			cwd: dir,
+			dot: true,
+			ignore: [
+				...ignore,
+				"**/*.vue",
+				"**/_*"
+			],
+			absolute: true
+		}).catch(() => []);
+		for (const fullPath of files.sort()) {
+			if (seenFullPaths.has(fullPath)) continue;
+			seenFullPaths.add(fullPath);
+			const relativePath = toPosixPath(relative(dir, fullPath));
+			const ext = extname(relativePath);
+			const base = basename(relativePath, ext);
+			const { order: _order, cleanName: code } = splitOrderPrefix(base);
+			const dirPart = dirname(relativePath) === "." ? "" : dirname(relativePath);
+			let namespace;
+			let finalCode = code;
+			let isDefault = code === "default" || base.startsWith("default.");
+			if (dirPart) {
+				const dirParts = dirPart.split("/");
+				const isIndexFile = code === "index";
+				finalCode = dirParts[0];
+				const nsParts = [];
+				nsParts.push(...dirParts.slice(1));
+				if (!isIndexFile) nsParts.push(code);
+				if (nsParts.length > 0) namespace = nsParts.join(".");
+			}
+			let name;
+			let dirVal;
+			try {
+				const { meta } = await loadLocaleFile(fullPath, ext);
+				if (meta?.name) name = meta.name;
+				if (meta?.dir) dirVal = meta.dir;
+				if (meta?.isDefault) isDefault = true;
+			} catch {
+				logger.warn(`Failed to parse locale file: ${relativePath}`);
+			}
+			if (isDefault && finalCode === "default") finalCode = "en";
+			locales.push({
+				fullPath,
+				relativePath,
+				dirname: dirname(relativePath),
+				basename: basename(relativePath),
+				code: finalCode,
+				namespace,
+				isDefault,
+				name,
+				dir: dirVal
+			});
+		}
+	}
+	return locales;
+}
+async function scanAppEntry(srcDir) {
+	const result = {
+		shared: { exists: false },
+		server: { exists: false },
+		client: { exists: false }
+	};
+	const findEntry = async (baseName) => {
+		for (const ext of APP_EXTENSIONS) {
+			const fullPath = join(srcDir, `${baseName}.${ext}`);
+			if (await fileExists(fullPath)) return {
+				exists: true,
+				fullPath,
+				relativePath: `${baseName}.${ext}`
+			};
+		}
+		return { exists: false };
+	};
+	const [shared, server, client] = await Promise.all([
+		findEntry("app"),
+		findEntry("app.server"),
+		findEntry("app.client")
+	]);
+	result.shared = shared;
+	result.server = server;
+	result.client = client;
+	return result;
+}
+async function scanServerEntry(srcDir) {
+	const result = {
+		shared: { exists: false },
+		dev: { exists: false },
+		prod: { exists: false }
+	};
+	const findEntry = async (baseName) => {
+		for (const ext of APP_EXTENSIONS) {
+			const fullPath = join(srcDir, `${baseName}.${ext}`);
+			if (await fileExists(fullPath)) return {
+				exists: true,
+				fullPath,
+				relativePath: `${baseName}.${ext}`
+			};
+		}
+		return { exists: false };
+	};
+	const [shared, dev, prod] = await Promise.all([
+		findEntry("server"),
+		findEntry("server.dev"),
+		findEntry("server.prod")
+	]);
+	result.shared = shared;
+	result.dev = dev;
+	result.prod = prod;
+	return result;
+}
+async function fileExists(path) {
+	const { existsSync } = await import("node:fs");
+	return existsSync(path);
+}
+function routeToName(route) {
+	if (route === "/") return "Index";
+	return route.replace(/^\//, "").replace(/\/$/, "").split("/").map((seg) => {
+		if (seg.startsWith(":")) return seg.slice(1).replace("?", "").split("_").map(capitalize).join("");
+		return seg.split(/[-_]/).map(capitalize).join("");
+	}).join("");
+}
+/**
+* Build a `PageHead` from Markdown frontmatter.
+*
+* Only the `head` field is used, matching `unplugin-vue-markdown`'s
+* `headField: 'head'` option so SSR and client-side `useHead` stay in sync.
+*
+* Supported shape:
+* ```yaml
+* head:
+*   title: "Page Title"
+*   meta:
+*     - name: description
+*       content: ...
+*   link:
+*     - rel: canonical
+*       href: ...
+* ```
+*/
+function buildMarkdownHead(fm) {
+	if (!fm || typeof fm.head !== "object" || fm.head === null) return void 0;
+	const fmHead = fm.head;
+	const head = {};
+	if (typeof fmHead.title === "string") head.title = fmHead.title;
+	if (Array.isArray(fmHead.meta)) head.meta = fmHead.meta;
+	if (Array.isArray(fmHead.link)) head.link = fmHead.link;
+	if (Array.isArray(fmHead.script)) head.script = fmHead.script;
+	if (fmHead.htmlAttrs && typeof fmHead.htmlAttrs === "object") head.htmlAttrs = fmHead.htmlAttrs;
+	if (fmHead.bodyAttrs && typeof fmHead.bodyAttrs === "object") head.bodyAttrs = fmHead.bodyAttrs;
+	return Object.keys(head).length > 0 ? head : void 0;
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//#endregion
+//#region src/route-name.ts
+function generateRouteName(routePath) {
+	if (routePath === "/" || routePath === "") return "Index";
+	const segments = routePath.replace(/^\//, "").replace(/\/$/, "").split("/");
+	const nameSegments = [];
+	for (const segment of segments) {
+		if (segment.startsWith("(") && segment.endsWith(")")) continue;
+		if (segment.startsWith("[...")) {
+			const param = segment.slice(4, -1);
+			nameSegments.push(`All${formatParamName(param)}`);
+			continue;
+		}
+		if (segment.startsWith("[[")) {
+			const param = segment.slice(2, -2);
+			nameSegments.push(`${formatParamName(param)}Optional`);
+			continue;
+		}
+		if (segment.startsWith("[")) {
+			const param = segment.slice(1, -1);
+			nameSegments.push(formatParamName(param));
+			continue;
+		}
+		nameSegments.push(pascalCase(segment));
+	}
+	return nameSegments.join("") || "Index";
+}
+function generateLayoutName(layoutPath) {
+	const base = layoutPath.replace(/\.(vue|ts)$/, "");
+	if (base === "default" || base === "default/index") return "default";
+	return base.split("/").filter(Boolean).map((s) => pascalCase(s)).join("");
+}
+function generateApiRouteId(method, routePath) {
+	const routeName = generateRouteName(routePath);
+	return `${method.toLowerCase()}${routeName}`;
+}
+function formatParamName(param) {
+	return pascalCase(param.replace(/^\.{3}/, "").replace(/\?$/, ""));
+}
+//#endregion
+//#region src/router.ts
+var UbeanRouter = class {
+	apiContext;
+	middlewares;
+	pages;
+	layouts;
+	constructor() {
+		this.apiContext = createRouter();
+		this.middlewares = [];
+		this.pages = /* @__PURE__ */ new Map();
+		this.layouts = /* @__PURE__ */ new Map();
+	}
+	addApiRoute(route) {
+		const data = {
+			method: route.method?.toUpperCase() || "ALL",
+			path: route.route,
+			id: `${route.method}:${route.route}`,
+			filePath: route.fullPath
+		};
+		addRoute(this.apiContext, data.method, route.route, data);
+	}
+	addMiddleware(mw) {
+		this.middlewares.push({
+			path: "/**",
+			filePath: mw.fullPath,
+			order: mw.order,
+			global: mw.global
+		});
+		this.middlewares.sort((a, b) => a.order - b.order);
+	}
+	addPage(page) {
+		this.pages.set(page.name, {
+			name: page.name,
+			path: page.route,
+			filePath: page.fullPath,
+			layout: page.layout,
+			reuseTarget: page.reuseTarget
+		});
+	}
+	addLayout(layout) {
+		this.layouts.set(layout.name, {
+			name: layout.name,
+			filePath: layout.fullPath,
+			isDefault: layout.isDefault
+		});
+	}
+	matchApi(method, path) {
+		return findRoute(this.apiContext, method.toUpperCase(), path)?.data;
+	}
+	getMiddlewares() {
+		return [...this.middlewares];
+	}
+	getPages() {
+		return [...this.pages.values()];
+	}
+	getPage(name) {
+		return this.pages.get(name);
+	}
+	getLayout(name) {
+		return this.layouts.get(name);
+	}
+	getDefaultLayout() {
+		return [...this.layouts.values()].find((l) => l.isDefault);
+	}
+	getLayouts() {
+		return [...this.layouts.values()];
+	}
+	getPageRouteNames() {
+		return [...this.pages.keys()];
+	}
+};
+let _router = null;
+function useRouter() {
+	if (!_router) _router = new UbeanRouter();
+	return _router;
+}
+function createUbeanRouter() {
+	_router = new UbeanRouter();
+	return _router;
+}
+//#endregion
+export { UbeanRouter, createUbeanRouter, detectHttpExports, detectHttpExportsFromCode, extractDefineMeta, extractDefineMetaFromCode, extractDefinePage, extractDefinePageFromCode, filePathToRoute, generateApiRouteId, generateLayoutName, generateRouteName, scanProject, stripRouteGroups, useRouter };