@ubean/build 0.2.2 → 0.3.1

package/dist/codegen-CYk6X-Hn.js

@@ -0,0 +1,691 @@
+import { isAbsolute, join, normalize, relative } from "pathe";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { glob } from "tinyglobby";
+import { createUnimport, toTypeDeclarationFile } from "unimport";
+import openapiTS, { astToString } from "openapi-typescript";
+//#region src/codegen/auto-imports.ts
+const VUE_PRESET = {
+	from: "vue",
+	imports: [
+		"ref",
+		"computed",
+		"reactive",
+		"readonly",
+		"watch",
+		"watchEffect",
+		"watchPostEffect",
+		"watchSyncEffect",
+		"onMounted",
+		"onUnmounted",
+		"onBeforeMount",
+		"onBeforeUnmount",
+		"onUpdated",
+		"onBeforeUpdate",
+		"onActivated",
+		"onDeactivated",
+		"onErrorCaptured",
+		"onServerPrefetch",
+		"onRenderTracked",
+		"onRenderTriggered",
+		"provide",
+		"inject",
+		"shallowRef",
+		"shallowReactive",
+		"shallowReadonly",
+		"isRef",
+		"isReactive",
+		"isReadonly",
+		"isProxy",
+		"unref",
+		"toRef",
+		"toRefs",
+		"toRaw",
+		"markRaw",
+		"triggerRef",
+		"customRef",
+		"effectScope",
+		"getCurrentScope",
+		"onScopeDispose",
+		"defineComponent",
+		"defineAsyncComponent",
+		"defineProps",
+		"defineEmits",
+		"defineExpose",
+		"defineOptions",
+		"defineSlots",
+		"defineModel",
+		"useSlots",
+		"useAttrs",
+		"useTemplateRef",
+		"nextTick",
+		"toValue",
+		"useId",
+		"useCssModule",
+		"useCssVars",
+		"useTransitionState"
+	]
+};
+const VUE_MACROS_PRESET = {
+	from: "vue/macros",
+	imports: [
+		"$",
+		"$$",
+		"$ref",
+		"$computed",
+		"$shallowRef",
+		"$customRef",
+		"$toRef"
+	]
+};
+/**
+* Client-safe symbols sourced from the first-class `ubean/client` entry.
+* These are safe to auto-import in Vue components (browser-side) because
+* `@ubean/client` has zero build-time dependencies and no `node:*` imports.
+* (`ubean/runtime/vue` still works — it re-exports the same kernel — but
+* new code should prefer `ubean/client`.)
+*/
+const UBEAN_CLIENT_PRESET = {
+	from: "ubean/client",
+	imports: [
+		"definePage",
+		"defineMiddleware",
+		"defineApp",
+		"applyAppConfig",
+		"createDefaultAppConfig",
+		"t",
+		"useI18n",
+		"setLocale",
+		"useLocalePath",
+		"useSwitchLocalePath",
+		"useLocaleRoute",
+		"useLocaleHead",
+		"useColorMode",
+		"useScript",
+		"useSearch",
+		"useSeoMeta",
+		"usePage",
+		"useRouter",
+		"useHead",
+		"useViewTransition",
+		"useAsyncData",
+		"useFetch",
+		"useCacheViews",
+		"enablePageCache",
+		"disablePageCache",
+		"excludePageCache",
+		"includePageCache",
+		"isPageExcluded",
+		"resetRouteCache",
+		"invalidatePageCache",
+		"isPageCached",
+		"usePageTransition",
+		"setPageTransition",
+		"clearPageTransition",
+		"useReloadSignal",
+		"reloadPage",
+		"isReloading"
+	]
+};
+/**
+* Server-only symbols that come from the main `ubean` package.
+* These import the full ubean entry (which includes build tools like `vite`),
+* so they must only be used in server-side files (API routes, middleware, etc.).
+*/
+const UBEAN_SERVER_PRESET = {
+	from: "ubean",
+	imports: [
+		"defineHandlerMeta",
+		"useData",
+		"useAsyncData",
+		"useFetch",
+		"defineAction",
+		"defineServerFn",
+		"invokeServerFn",
+		"createInternalAdapter",
+		"defineScheduled",
+		"defineQueue",
+		"sendMessage",
+		"sendMessages",
+		"getQueueStats",
+		"useDatabase",
+		"defineDatabase",
+		"useKV",
+		"createKV",
+		"useStorage"
+	]
+};
+const HONO_OPENAPI_PRESET = {
+	from: "hono-openapi",
+	imports: ["validator", "describeRoute"]
+};
+const BUILTIN_PRESETS = [
+	UBEAN_CLIENT_PRESET,
+	UBEAN_SERVER_PRESET,
+	HONO_OPENAPI_PRESET
+];
+function toPosixPath(p) {
+	return p.replace(/\\/g, "/");
+}
+function toCamelCase(str) {
+	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+	const camel = toCamelCase(str);
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function fileBasename(p, ext) {
+	const parts = toPosixPath(p).split("/");
+	let base = parts[parts.length - 1] || "";
+	if (ext && base.endsWith(ext)) base = base.slice(0, -ext.length);
+	else if (!ext) {
+		const dotIdx = base.lastIndexOf(".");
+		if (dotIdx > 0) base = base.slice(0, dotIdx);
+	}
+	return base;
+}
+function fileDirname(p) {
+	const parts = toPosixPath(p).split("/");
+	parts.pop();
+	return parts.join("/") || ".";
+}
+function transformImportPath(filePath, srcDir) {
+	const posixPath = toPosixPath(normalize(filePath));
+	const posixSrcDir = toPosixPath(normalize(srcDir));
+	return `~/${toPosixPath(relative(posixSrcDir, posixPath)).replace(/\.(ts|js|mts|mjs|cts|cjs|tsx|jsx)$/, "")}`;
+}
+async function scanComponentsDir(dir, srcDir, directoryAsNamespace, ignore = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/_*"
+]) {
+	const components = [];
+	const files = await glob("**/*.vue", {
+		cwd: dir,
+		dot: true,
+		ignore,
+		absolute: true
+	}).catch(() => []);
+	for (const fullPath of files.sort()) {
+		const relativeToSrc = toPosixPath(relative(srcDir, fullPath));
+		const relativeToDir = toPosixPath(relative(dir, fullPath));
+		const base = fileBasename(fullPath);
+		if (base.startsWith("_")) continue;
+		let name;
+		if (directoryAsNamespace) {
+			const dirPart = fileDirname(relativeToDir) === "." ? "" : fileDirname(relativeToDir);
+			const parts = dirPart ? dirPart.split("/").filter(Boolean) : [];
+			parts.push(base);
+			name = parts.map(toPascalCase).join("");
+		} else name = toPascalCase(base);
+		components.push({
+			name,
+			filePath: fullPath,
+			importPath: `~/${relativeToSrc}`,
+			pascalName: name
+		});
+	}
+	return components;
+}
+async function generateAutoImports(_scanResult, options) {
+	const { cwd, srcDir, buildDir, composablesDirs = [], componentsDirs = [], dirs = {}, imports: importsConfig, components: componentsConfig } = options;
+	const outDir = join(cwd, buildDir);
+	await mkdir(outDir, { recursive: true });
+	const autoImportEnabled = importsConfig?.autoImport !== false;
+	const componentAutoImportEnabled = componentsConfig?.autoImport !== false;
+	const directoryAsNamespace = componentsConfig?.directoryAsNamespace ?? false;
+	const composablesDir = dirs.composables || "composables";
+	const componentsDir = dirs.components || "components";
+	let composablesImports = [];
+	let components = [];
+	const autoImportsDtsPath = join(outDir, "auto-imports.d.ts");
+	const componentsDtsPath = join(outDir, "components.d.ts");
+	if (autoImportEnabled) {
+		const allComposablesDirs = [join(srcDir, composablesDir), ...composablesDirs];
+		const existingDirs = [];
+		for (const dir of allComposablesDirs) try {
+			const { statSync } = await import("node:fs");
+			if (statSync(dir).isDirectory()) existingDirs.push(dir);
+		} catch {}
+		const unimport = createUnimport({
+			presets: BUILTIN_PRESETS,
+			dirs: existingDirs,
+			dirsScanOptions: {
+				cwd: srcDir,
+				filePatterns: ["*.{ts,js,mts,mjs,cts,cjs}"],
+				types: false
+			}
+		});
+		await unimport.init();
+		composablesImports = (await unimport.getImports()).map((imp) => {
+			if (imp.from === "vue" || imp.from === "vue/macros" || imp.from === "ubean" || imp.from.startsWith("ubean/")) return imp;
+			return {
+				...imp,
+				from: transformImportPath(imp.from, srcDir)
+			};
+		});
+		const dtsContent = toTypeDeclarationFile(composablesImports, { resolvePath: (imp) => {
+			if (imp.from === "vue" || imp.from === "vue/macros" || imp.from === "ubean" || imp.from.startsWith("ubean/")) return imp.from;
+			return transformImportPath(imp.from, srcDir);
+		} });
+		await writeFile(autoImportsDtsPath, dtsContent, "utf-8");
+	} else await writeFile(autoImportsDtsPath, "// Auto-generated by ubean - auto-imports disabled\n/* eslint-disable */\n// @ts-nocheck\nexport {}\n", "utf-8");
+	if (componentAutoImportEnabled) {
+		const allComponentsDirs = [join(srcDir, componentsDir), ...componentsDirs];
+		for (const dir of allComponentsDirs) {
+			const scanned = await scanComponentsDir(dir, srcDir, directoryAsNamespace);
+			components.push(...scanned);
+		}
+	}
+	const componentsDts = generateComponentsDts(components, componentsDtsPath);
+	await writeFile(componentsDtsPath, componentsDts, "utf-8");
+	return {
+		composablesImports,
+		components,
+		autoImportsDtsPath,
+		componentsDtsPath
+	};
+}
+/**
+* Generate the `.ubean/components.d.ts` in a format compatible with
+* unplugin-vue-components (both writers own the same file).
+*
+* `ubean dev` runs codegen first, then unplugin-vue-components rewrites the
+* file in dev mode using its append merge: it keeps entries scraped from the
+* existing `GlobalComponents` interface but drops any surrounding
+* `import`/`const` declaration lines. Entries must therefore be
+* self-contained inline `typeof import('...')` declarations so they stay
+* valid after unplugin merges them.
+*/
+function generateComponentsDts(components, dtsPath) {
+	const dtsDir = fileDirname(toPosixPath(normalize(dtsPath)));
+	const entries = /* @__PURE__ */ new Map();
+	for (const name of [
+		"Link",
+		"Head",
+		"PageView"
+	]) entries.set(name, `typeof import('ubean/client')['${name}']`);
+	for (const comp of components) {
+		const importPath = `./${toPosixPath(relative(dtsDir, toPosixPath(normalize(comp.filePath))))}`;
+		entries.set(comp.pascalName, `typeof import('${importPath}')['default']`);
+	}
+	const lines = [
+		"// Auto-generated by ubean - do not edit manually",
+		"/* eslint-disable */",
+		"// @ts-nocheck",
+		"// biome-ignore lint: disable",
+		"// oxlint-disable",
+		"",
+		"export {}",
+		"",
+		"/* prettier-ignore */",
+		"declare module 'vue' {",
+		"  export interface GlobalComponents {"
+	];
+	const sorted = [...entries.entries()].sort(([a], [b]) => a.localeCompare(b));
+	lines.push(...sorted.map(([name, declaration]) => `    ${name}: ${declaration}`));
+	lines.push("  }");
+	lines.push("}");
+	lines.push("");
+	return `${lines.join("\n")}\n`;
+}
+function getBuiltinComposables() {
+	const imports = [];
+	for (const preset of BUILTIN_PRESETS) for (const name of preset.imports) if (typeof name === "string") imports.push({
+		name,
+		from: preset.from
+	});
+	else if (Array.isArray(name)) imports.push({
+		name: name[0],
+		as: name[1],
+		from: preset.from
+	});
+	return imports;
+}
+function getUbeanAutoImportConfig(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const srcDir = options.srcDir || join(cwd, "src");
+	const buildDir = options.buildDir || ".ubean";
+	const composablesDirs = [join(srcDir, "composables"), ...options.composablesDirs || []];
+	return {
+		imports: [
+			UBEAN_CLIENT_PRESET,
+			UBEAN_SERVER_PRESET,
+			HONO_OPENAPI_PRESET
+		],
+		dirs: composablesDirs,
+		dts: join(cwd, buildDir, "auto-imports.d.ts"),
+		vueTemplate: true,
+		eslintrc: { enabled: false }
+	};
+}
+function getUbeanComponentsConfig(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const srcDir = options.srcDir || join(cwd, "src");
+	const buildDir = options.buildDir || ".ubean";
+	return {
+		dirs: [join(srcDir, "components"), ...options.componentsDirs || []],
+		extensions: ["vue"],
+		directoryAsNamespace: options.directoryAsNamespace ?? false,
+		dts: join(cwd, buildDir, "components.d.ts"),
+		deep: true
+	};
+}
+function generateImportsTransform(imports) {
+	const importGroups = /* @__PURE__ */ new Map();
+	for (const imp of imports) {
+		if (!importGroups.has(imp.from)) importGroups.set(imp.from, /* @__PURE__ */ new Set());
+		const namePart = imp.as ? `${imp.name} as ${imp.as}` : imp.name;
+		importGroups.get(imp.from).add(namePart);
+	}
+	const importStatements = [];
+	for (const [from, names] of importGroups) importStatements.push(`import { ${Array.from(names).join(", ")} } from '${from}';`);
+	return { code: importStatements.join("\n") };
+}
+//#endregion
+//#region src/codegen/i18n-types.ts
+function isIdent(key) {
+	return /^[A-Za-z_$][\w$]*$/.test(key);
+}
+/** Convert a JSON message tree into a TypeScript object type body. */
+function messagesToTsType(value, indent = 1) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return "string";
+	const obj = value;
+	const keys = Object.keys(obj);
+	if (keys.length === 0) return "Record<string, never>";
+	const pad = "  ".repeat(indent);
+	return `{\n${keys.map((k) => {
+		const key = isIdent(k) ? k : JSON.stringify(k);
+		return `${pad}${key}: ${messagesToTsType(obj[k], indent + 1)};`;
+	}).join("\n")}\n${"  ".repeat(indent - 1)}}`;
+}
+function unwrapMessages(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const obj = raw;
+	if ((typeof obj.name === "string" || obj.dir === "ltr" || obj.dir === "rtl" || typeof obj.isDefault === "boolean") && obj.messages && typeof obj.messages === "object" && obj.messages !== null) return obj.messages;
+	return obj;
+}
+function pickDefaultLocaleFile(locales, defaultLocale) {
+	const jsonFiles = locales.filter((l) => {
+		const lower = l.fullPath.toLowerCase();
+		return (lower.endsWith(".json") || lower.endsWith(".json5")) && !l.namespace;
+	});
+	if (jsonFiles.length === 0) return void 0;
+	if (defaultLocale) {
+		const match = jsonFiles.find((l) => l.code === defaultLocale);
+		if (match) return match;
+	}
+	return jsonFiles.find((l) => l.isDefault) || jsonFiles[0];
+}
+/**
+* Generate `.ubean/i18n.d.ts` augmenting vue-i18n `DefineLocaleMessage`
+* from the default locale JSON. Users can also hand-write the same
+* module augmentation if they prefer.
+*/
+async function generateI18nTypes(result, options) {
+	const { outDir, fileName = "i18n.d.ts", defaultLocale } = options;
+	const source = pickDefaultLocaleFile(result.locales || [], defaultLocale);
+	if (!source) return null;
+	let raw;
+	try {
+		const text = await readFile(source.fullPath, "utf8");
+		raw = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	const messages = unwrapMessages(raw);
+	if (!messages) return null;
+	const typeBody = messagesToTsType(messages, 2);
+	const contents = `// Auto-generated by ubean from ${source.relativePath} — do not edit manually
+// Typed \`t('key')\` via vue-i18n \`DefineLocaleMessage\`.
+// Override by adding your own \`declare module 'vue-i18n'\` in src/.
+/* eslint-disable */
+export {};
+
+declare module 'vue-i18n' {
+  export interface DefineLocaleMessage ${typeBody}
+}
+`;
+	await mkdir(outDir, { recursive: true });
+	const outPath = join(outDir, fileName);
+	await writeFile(outPath, contents, "utf8");
+	return outPath;
+}
+//#endregion
+//#region src/codegen/route-types.ts
+/**
+* Compute a portable file path for a scanned route.
+*
+* - If `fullPath` is under `cwd`, returns a POSIX-style project-relative path
+*   (e.g. `src/routes/api/users/[id].ts`). This keeps generated `.d.ts` files
+*   portable across machines and free of leaked absolute paths.
+* - Otherwise, falls back to the raw `fullPath` (already non-sensitive for
+*   non-local sources).
+*/
+function toPortableFilePath(route, cwd) {
+	return (isAbsolute(route.fullPath) ? relative(cwd, route.fullPath) : route.fullPath).replace(/\\/g, "/");
+}
+async function generateRouteTypes(result, options) {
+	const { cwd, outDir, fileName = "routes.d.ts" } = options;
+	await mkdir(outDir, { recursive: true });
+	const apiRoutes = result.apiRoutes;
+	const lines = [
+		"// Auto-generated by ubean - do not edit manually",
+		"/* eslint-disable */",
+		"// @ts-nocheck",
+		"",
+		"declare module \"ubean:routes\" {",
+		"  export interface ApiRoute {",
+		"    method: string;",
+		"    path: string;",
+		"    filePath: string;",
+		"    meta?: Record<string, unknown>;",
+		"  }",
+		""
+	];
+	if (apiRoutes.length > 0) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const r of apiRoutes) {
+			const list = groups.get(r.route);
+			if (list) list.push(r);
+			else groups.set(r.route, [r]);
+		}
+		const entries = [];
+		for (const [path, routes] of groups) {
+			const methodEntries = routes.map((r) => {
+				const method = (r.method || "ALL").toUpperCase();
+				const filePath = toPortableFilePath(r, cwd);
+				return `      ${method}: { filePath: ${JSON.stringify(filePath)} }`;
+			}).join(";\n");
+			entries.push(`    ${JSON.stringify(path)}: {\n${methodEntries}\n    }`);
+		}
+		lines.push("  export type ApiRouteMap = {");
+		lines.push(`${entries.join(";\n")};`);
+		lines.push("  };");
+	} else lines.push("  export type ApiRouteMap = {};");
+	lines.push("");
+	if (apiRoutes.length > 0) lines.push("  export type ApiRoutePath = keyof ApiRouteMap;");
+	else lines.push("  export type ApiRoutePath = string;");
+	lines.push("");
+	const routeMethods = [...new Set(apiRoutes.map((r) => r.method?.toUpperCase()).filter(Boolean))].sort();
+	if (routeMethods.length > 0) {
+		lines.push("  export type ApiMethod =");
+		lines.push(routeMethods.map((m) => `    | ${JSON.stringify(m)}`).join("\n"));
+		lines.push("  ;");
+	} else lines.push("  export type ApiMethod = \"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\" | \"OPTIONS\" | \"HEAD\";");
+	lines.push("");
+	lines.push("  export const routes: ApiRoute[];");
+	lines.push("  export const middlewares: { filePath: string; order: number; global: boolean }[];");
+	lines.push("}");
+	const content = `${lines.join("\n")}\n`;
+	const filePath = join(outDir, fileName);
+	await writeFile(filePath, content, "utf-8");
+	return filePath;
+}
+async function generatePageTypes(result, options) {
+	const { outDir, fileName = "pages.d.ts" } = options;
+	await mkdir(outDir, { recursive: true });
+	const pages = result.pages;
+	const layouts = result.layouts;
+	const lines = [
+		"// Auto-generated by ubean - do not edit manually",
+		"/* eslint-disable */",
+		"// @ts-nocheck",
+		"",
+		"declare module \"ubean:pages\" {",
+		"  export interface PageInfo {",
+		"    name: string;",
+		"    path: string;",
+		"    filePath: string;",
+		"    layout?: string;",
+		"    reuseTarget?: string;",
+		"  }",
+		"",
+		"  export interface LayoutInfo {",
+		"    name: string;",
+		"    filePath: string;",
+		"    isDefault: boolean;",
+		"  }",
+		""
+	];
+	const pageNames = pages.map((p) => JSON.stringify(p.name));
+	if (pageNames.length > 0) {
+		lines.push("  export type RouteName =");
+		lines.push(pageNames.map((n) => `    | ${n}`).join("\n"));
+		lines.push("  ;");
+	} else lines.push("  export type RouteName = string;");
+	lines.push("");
+	const layoutNames = layouts.map((l) => JSON.stringify(l.name));
+	if (layoutNames.length > 0) {
+		lines.push("  export type LayoutName =");
+		lines.push(layoutNames.map((n) => `    | ${n}`).join("\n"));
+		lines.push("  ;");
+	} else lines.push("  export type LayoutName = string;");
+	lines.push("");
+	lines.push("  export const pages: Record<RouteName, PageInfo>;");
+	lines.push("  export const layouts: Record<LayoutName, LayoutInfo>;");
+	lines.push("}");
+	const content = `${lines.join("\n")}\n`;
+	const filePath = join(outDir, fileName);
+	await writeFile(filePath, content, "utf-8");
+	return filePath;
+}
+//#endregion
+//#region src/codegen/openapi-types.ts
+/**
+* OpenAPI 类型生成
+*
+* 从 OpenAPI schema 生成 `paths` 类型声明文件(.ubean/openapi.d.ts),
+* 供 `createTypedClient<paths>` / `createTypedFlatClient<paths>` / `callTypedInternal<paths>` 消费。
+*
+* 底层使用 `openapi-typescript` 编译 schema 为 TypeScript 类型声明。
+*/
+/**
+* 从 OpenAPI schema 对象生成 paths 类型声明文件。
+*/
+async function generateOpenApiTypes(schema, options) {
+	const { outDir, fileName = "openapi.d.ts" } = options;
+	await mkdir(outDir, { recursive: true });
+	const ast = await openapiTS(schema);
+	const typesContent = astToString(ast);
+	const content = `${[
+		"// Auto-generated by ubean - do not edit manually",
+		"/* eslint-disable */",
+		"/* @ts-nocheck */",
+		"",
+		""
+	].join("\n") + typesContent}\n`;
+	const filePath = join(outDir, fileName);
+	await writeFile(filePath, content, "utf-8");
+	return filePath;
+}
+/**
+* 从 dev server 的 `/_openapi.json` 路由获取 schema 并生成类型声明文件。
+*/
+async function generateOpenApiTypesFromServer(baseUrl, options) {
+	const url = `${baseUrl.replace(/\/$/, "")}/_openapi.json`;
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`[openapi-types] Failed to fetch OpenAPI schema from ${url}: ${response.status} ${response.statusText}`);
+	return generateOpenApiTypes(await response.json(), options);
+}
+//#endregion
+//#region src/codegen/index.ts
+const CODEGEN_CONTRACT_VERSION = 1;
+const CODEGEN_FILES = [
+	{
+		name: "routes.d.ts",
+		module: "ubean:routes",
+		required: true,
+		types: [
+			"ApiRouteMap",
+			"ApiRoutePath",
+			"ApiMethod"
+		]
+	},
+	{
+		name: "pages.d.ts",
+		module: "ubean:pages",
+		required: true,
+		types: ["RouteName", "LayoutName"]
+	},
+	{
+		name: "i18n.d.ts",
+		module: "vue-i18n",
+		required: false,
+		types: ["DefineLocaleMessage"]
+	},
+	{
+		name: "auto-imports.d.ts",
+		module: null,
+		required: true,
+		types: []
+	},
+	{
+		name: "components.d.ts",
+		module: null,
+		required: true,
+		types: []
+	}
+];
+async function generateTypes(result, options) {
+	const { cwd, srcDir, buildDir, ...autoImportOptions } = options;
+	const outDir = join(cwd, buildDir);
+	await mkdir(outDir, { recursive: true });
+	const generated = [];
+	const routeTypesPath = await generateRouteTypes(result, {
+		cwd,
+		outDir
+	});
+	generated.push(routeTypesPath);
+	const pageTypesPath = await generatePageTypes(result, { outDir });
+	generated.push(pageTypesPath);
+	const i18nTypesPath = await generateI18nTypes(result, { outDir });
+	if (i18nTypesPath) generated.push(i18nTypesPath);
+	const { autoImportsDtsPath, componentsDtsPath } = await generateAutoImports(result, {
+		cwd,
+		srcDir,
+		buildDir,
+		...autoImportOptions
+	});
+	generated.push(autoImportsDtsPath, componentsDtsPath);
+	const manifest = {
+		contractVersion: 1,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		files: CODEGEN_FILES.map((file) => ({
+			...file,
+			generated: generated.some((path) => path.replace(/\\/g, "/").endsWith(`/${file.name}`) || path.endsWith(file.name))
+		}))
+	};
+	const manifestPath = join(outDir, "codegen.manifest.json");
+	await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+	generated.push(manifestPath);
+	return {
+		routeTypesPath,
+		pageTypesPath,
+		i18nTypesPath,
+		autoImportsDtsPath,
+		componentsDtsPath,
+		generated
+	};
+}
+//#endregion
+export { generateImportsTransform as _, generateOpenApiTypesFromServer as a, getUbeanComponentsConfig as b, generateI18nTypes as c, HONO_OPENAPI_PRESET as d, UBEAN_CLIENT_PRESET as f, generateAutoImports as g, VUE_PRESET as h, generateOpenApiTypes as i, messagesToTsType as l, VUE_MACROS_PRESET as m, CODEGEN_FILES as n, generatePageTypes as o, UBEAN_SERVER_PRESET as p, generateTypes as r, generateRouteTypes as s, CODEGEN_CONTRACT_VERSION as t, BUILTIN_PRESETS as u, getBuiltinComposables as v, getUbeanAutoImportConfig as y };