@ubean/build 0.1.2 → 0.1.3

package/dist/production.js

@@ -0,0 +1,611 @@
+import { a as createRoutingVirtualModule, f as useVirtualRegistry, i as createPagesVirtualModule, n as createLocalesVirtualModule, r as createMetaVirtualModule, t as createAppVirtualModule } from "./virtual-modules-DXIaZdQI.js";
+import { ubeanPlugin } from "./vite.js";
+import { join, relative, resolve } from "pathe";
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { build } from "vite";
+import vue from "@vitejs/plugin-vue";
+import { ubeanIslandsPlugin } from "@ubean/islands";
+import { resolveModules } from "@ubean/modules";
+import { findUserViteConfig } from "@ubean/utils";
+import { VUE_PLUGIN_INCLUDE, createClientEntryVirtualModule, createServerEntryVirtualModule, createVueAppEntryVirtualModule, createVuePagesVirtualModule, ubeanVuePlugin } from "@ubean/vite";
+import { consola } from "consola";
+//#region src/production.ts
+const logger = consola.withTag("ubean-build");
+function getOutDirs(cwd, outputDir) {
+	const outputRoot = resolve(cwd, outputDir);
+	return {
+		root: outputRoot,
+		public: join(outputRoot, "public"),
+		server: join(outputRoot, "server"),
+		assets: join(outputRoot, "public", "assets"),
+		virtual: join(cwd, ".ubean", "virtual")
+	};
+}
+function toVitePath(p) {
+	return p.replace(/\\/g, "/");
+}
+async function generateVirtualModulesToDisk(cwd, config, scanResult, virtualDir) {
+	const mode = config.mode;
+	const ssrEnabled = mode === "fullstack" && config.ssr || mode === "ssg";
+	const hasPages = mode !== "backend";
+	const hasServer = mode !== "spa";
+	await mkdir(virtualDir, { recursive: true });
+	const registry = useVirtualRegistry();
+	registry.clear();
+	const viteSrcDir = toVitePath(relative(cwd, resolve(cwd, config.srcDir)));
+	const viteSrcPrefix = viteSrcDir ? `/${viteSrcDir}` : "";
+	registry.register(createRoutingVirtualModule(scanResult.apiRoutes.map((r) => ({
+		method: r.method?.toUpperCase() || "ALL",
+		path: r.route,
+		id: `${r.method}:${r.route}`,
+		filePath: r.fullPath
+	})), scanResult.middlewares.map((m) => ({
+		path: "/**",
+		filePath: m.fullPath,
+		order: m.order,
+		global: m.global
+	}))));
+	if (hasPages) {
+		registry.register(createPagesVirtualModule(scanResult.pages.map((p) => ({
+			name: p.name,
+			path: p.route,
+			filePath: p.fullPath,
+			layout: p.layout,
+			reuseTarget: p.reuseTarget
+		})), scanResult.layouts.map((l) => ({
+			name: l.name,
+			filePath: l.fullPath,
+			isDefault: l.isDefault
+		}))));
+		registry.register(createMetaVirtualModule());
+		registry.register(createVuePagesVirtualModule(scanResult.pages, scanResult.layouts));
+		registry.register(createVueAppEntryVirtualModule(scanResult.appEntry));
+		registry.register(createClientEntryVirtualModule());
+	}
+	registry.register(createAppVirtualModule(scanResult.apiRoutes, scanResult.middlewares, hasPages ? scanResult.pages : [], viteSrcPrefix || "/"));
+	registry.register(createLocalesVirtualModule(scanResult.locales, scanResult.defaultLocale, viteSrcPrefix || "/"));
+	if (hasServer) registry.register(createServerEntryVirtualModule(scanResult.serverEntry));
+	async function writeModule(id, filename, header = "// Auto-generated by ubean\n") {
+		const mod = registry.getModules().find((m) => m.id === id);
+		const content = mod ? await mod.load() : "";
+		await writeFile(join(virtualDir, filename), header + content, "utf-8");
+	}
+	await writeModule("ubean:routes", "routes.mjs");
+	await writeModule("ubean:app-config", "app-config.mjs");
+	await writeModule("ubean:locales", "locales.mjs");
+	if (hasPages) {
+		await writeModule("ubean:pages", "pages.ts");
+		await writeModule("ubean:meta", "meta.mjs");
+		await writeModule("virtual:ubean-pages", "vue-pages.ts", "");
+		await writeModule("virtual:ubean-app", "vue-app.ts", "");
+		await writeModule("virtual:ubean-client-entry", "client-entry.mjs", "");
+	}
+	if (hasServer) await writeModule("virtual:ubean-server", "server-entry.ts", "");
+	const pagesGlob = JSON.stringify(`${viteSrcPrefix}/pages/**/*.{vue,ts,tsx,js,jsx,md,mdx}`);
+	const routesGlob = JSON.stringify(`${viteSrcPrefix}/routes/**/*.{ts,js,mjs}`);
+	const middlewareGlob = JSON.stringify(`${viteSrcPrefix}/middleware/**/*.{ts,js,mjs}`);
+	const layoutsGlob = JSON.stringify(`${viteSrcPrefix}/layouts/**/*.{vue,ts}`);
+	const publicDir = toVitePath(resolve(cwd, config.build.outputDir || "dist", "public"));
+	const routesJson = JSON.stringify(scanResult.apiRoutes.map((r) => ({
+		relativePath: r.relativePath,
+		route: r.route,
+		method: r.method,
+		fileMeta: r.fileMeta
+	})));
+	const middlewareJson = JSON.stringify(scanResult.middlewares.map((m) => ({
+		relativePath: m.relativePath,
+		order: m.order,
+		global: m.global
+	})));
+	const pagesJson = JSON.stringify(scanResult.pages.map((p) => ({
+		relativePath: p.relativePath,
+		name: p.name,
+		route: p.route,
+		layout: p.layout,
+		reuseTarget: p.reuseTarget,
+		isReuse: p.isReuse,
+		pageMeta: p.pageMeta
+	})));
+	const layoutsJson = JSON.stringify(scanResult.layouts.map((l) => ({
+		name: l.name,
+		relativePath: l.relativePath,
+		isDefault: l.isDefault
+	})));
+	const rendererImport = ssrEnabled ? `import { createVueRenderer } from 'ubean/vue-ssr';` : "";
+	const rendererSetup = ssrEnabled ? `
+// --- SSR renderer setup ---
+const _defaultLayout = _layouts.find(l => l.isDefault)?.name || null;
+
+const _rendererRoutes = _pages.map(p => {
+  // For reuse routes, load the target page's module (the .reuse.ts file
+  // only contains definePage metadata, not a Vue component).
+  const _targetPage = p.isReuse && p.reuseTarget ? _pages.find(tp => tp.name === p.reuseTarget) : undefined;
+  const _loaderKey = _targetPage?.relativePath || p.relativePath;
+  return {
+    path: p.route.replace(/\\*\\*:(\\w[\\w-]*)/g, ':$1(.*)*'),
+    name: p.name,
+    component: async () => {
+      const loader = pageLoaders[_loaderKey];
+      if (!loader) throw new Error('Page loader not found: ' + _loaderKey);
+      const mod = await loader();
+      return mod.default || mod;
+    },
+    meta: {
+      layout: p.layout === false ? false : p.layout || _defaultLayout,
+      pageName: p.name,
+      cache: p.cache === true ? true : undefined
+    }
+  };
+});
+
+const _layoutMap = new Map();
+for (const l of _layouts) {
+  _layoutMap.set(l.name, l.relativePath);
+}
+
+const _pageRenderer = createVueRenderer({
+  routes: _rendererRoutes,
+  async resolveLayoutComponent(name) {
+    if (name === false || name == null) return null;
+    const relPath = _layoutMap.get(name);
+    if (!relPath) return null;
+    const loader = layoutLoaders[relPath];
+    if (!loader) return null;
+    const mod = await loader();
+    return mod.default || mod;
+  },
+  defaultLayout: _defaultLayout,
+  resolveAppConfig: () => _resolveAppConfig('server')
+});
+` : `
+// --- SSR disabled (mode=${mode}, ssr=${config.ssr}) ---
+// pageRenderer is null; page requests fall back to a client-only HTML shell.
+const _pageRenderer = null;`;
+	if (hasServer) {
+		const serverEntry = `// Auto-generated server entry
+import { createUbeanApp, applyServerConfig } from 'ubean/runtime/app';
+${rendererImport}
+import { resolveAppConfig as _resolveAppConfig } from 'virtual:ubean-app';
+import { resolveServerConfig as _resolveServerConfig } from 'virtual:ubean-server';
+import { loadLocales } from 'ubean:locales';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export { createUbeanApp };
+
+const routeModules = import.meta.glob(${routesGlob}, { eager: false });
+const middlewareModules = import.meta.glob(${middlewareGlob}, { eager: false });
+const pageModules = import.meta.glob(${pagesGlob}, { eager: false });
+const layoutModules = import.meta.glob(${layoutsGlob}, { eager: false });
+
+const _srcPrefix = ${JSON.stringify(viteSrcPrefix)};
+function normalizeKey(p) {
+  const prefixes = ['/routes/', '/middleware/', '/pages/', '/layouts/'];
+  for (const prefix of prefixes) {
+    const fullPrefix = _srcPrefix + prefix;
+    if (p.includes(fullPrefix)) {
+      const idx = p.indexOf(fullPrefix);
+      return p.slice(idx + fullPrefix.length);
+    }
+  }
+  return p;
+}
+
+export const routeLoaders = {};
+for (const [key, loader] of Object.entries(routeModules)) {
+  routeLoaders[normalizeKey(key)] = loader;
+}
+
+export const middlewareLoaders = {};
+for (const [key, loader] of Object.entries(middlewareModules)) {
+  middlewareLoaders[normalizeKey(key)] = loader;
+}
+
+export const pageLoaders = {};
+for (const [key, loader] of Object.entries(pageModules)) {
+  pageLoaders[normalizeKey(key)] = loader;
+}
+
+const layoutLoaders = {};
+for (const [key, loader] of Object.entries(layoutModules)) {
+  layoutLoaders[normalizeKey(key)] = loader;
+}
+
+const _routes = ${routesJson};
+const _middleware = ${middlewareJson};
+const _pages = ${pagesJson};
+const _layouts = ${layoutsJson};
+${rendererSetup}
+// --- Client asset tags from Vite manifest ---
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let _assetTags = { css: '', preloads: '', body: '' };
+try {
+  const manifestPath = join(__dirname, '..', 'public', '.vite', 'manifest.json');
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const entry = Object.values(manifest).find(m => m.isEntry);
+  if (entry) {
+    _assetTags.body = '<script type="module" src="/' + entry.file + '"><\/script>';
+    if (Array.isArray(entry.css)) {
+      _assetTags.css = entry.css.map(c => '<link rel="stylesheet" href="/' + c + '">').join('\\n');
+    }
+  }
+} catch (e) {
+  console.warn('[ubean] Failed to load client manifest:', e.message || e);
+}
+
+export async function createApp(options = {}) {
+  const app = createUbeanApp({
+    rootDir: ${JSON.stringify(cwd)},
+    routes: _routes,
+    middleware: _middleware,
+    pages: _pages,
+    layouts: _layouts,
+    routeLoaders,
+    middlewareLoaders,
+    pageLoaders,
+    pageRenderer: _pageRenderer,
+    pageAssetTags: _assetTags,
+    publicDir: ${JSON.stringify(publicDir)},
+    i18nConfig: ${JSON.stringify(config.i18n)},
+    ...options
+  });
+
+  // Apply user's defineServer config (plugins, hooks, onAppCreate) before init
+  const _serverConfig = _resolveServerConfig('prod');
+  await applyServerConfig(app, _serverConfig);
+
+  await loadLocales();
+  await app.init();
+
+  // Call onServerReady after init completes
+  if (_serverConfig.onServerReady) {
+    await _serverConfig.onServerReady(app);
+  }
+
+  return app;
+}
+
+export default async function createFetchHandler() {
+  const app = await createApp();
+  return app.fetch;
+}
+
+export const handler = async (req, ctx) => {
+  const app = await createApp();
+  return app.fetch(req, ctx);
+};
+`;
+		await writeFile(join(virtualDir, "server-entry.mjs"), serverEntry, "utf-8");
+	}
+	return virtualDir;
+}
+function getPresetBuildConfig(preset) {
+	switch (preset.name) {
+		case "node":
+		case "bun":
+		case "deno": return {
+			format: "esm",
+			target: "node18",
+			entryType: "node",
+			external: [
+				"hono",
+				"vue",
+				"vue/server-renderer",
+				/^ubean(\/.*)?$/,
+				/^node:/
+			]
+		};
+		case "cloudflare": return {
+			format: "esm",
+			target: "es2022",
+			entryType: "worker",
+			external: [
+				"hono",
+				"vue",
+				"vue/server-renderer",
+				/^ubean(\/.*)?$/
+			]
+		};
+		default: return {
+			format: "esm",
+			target: "es2022",
+			entryType: "fetch",
+			external: [
+				"hono",
+				"vue",
+				"vue/server-renderer",
+				/^ubean(\/.*)?$/
+			]
+		};
+	}
+}
+function generateNodeServerEntry() {
+	return `// Auto-generated ubean Node.js server entry
+import { createServer } from 'node:http';
+import createFetchHandler from './entry.mjs';
+
+const port = Number(process.env.PORT || 9527);
+const host = process.env.HOST || '0.0.0.0';
+
+async function main() {
+  const fetch = await createFetchHandler();
+
+  const server = createServer(async (req, res) => {
+    try {
+      const protocol = req.socket?.encrypted ? 'https' : 'http';
+      const url = \`\${protocol}://\${req.headers.host || host}\${req.url || '/'}\`;
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+          if (Array.isArray(value)) {
+            for (const v of value) headers.append(key, v);
+          } else {
+            headers.set(key, value);
+          }
+        }
+      }
+      const method = req.method || 'GET';
+      const body = method === 'GET' || method === 'HEAD' ? undefined : req;
+      const webReq = new Request(url, { method, headers, body, duplex: 'half' });
+      const webRes = await fetch(webReq);
+
+      res.statusCode = webRes.status;
+      res.statusMessage = webRes.statusText;
+      webRes.headers.forEach((value, key) => res.setHeader(key, value));
+
+      if (webRes.body) {
+        const reader = webRes.body.getReader();
+        try {
+          while (true) {
+            const { done, value: chunk } = await reader.read();
+            if (done) break;
+            res.write(chunk);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      res.end();
+    } catch (err) {
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader('Content-Type', 'text/plain');
+      }
+      res.end(err instanceof Error ? err.message : String(err));
+    }
+  });
+
+  server.listen(port, host, () => {
+    console.log(\`ubean server listening on http://\${host}:\${port}\`);
+  });
+
+  const shutdown = () => {
+    server.close(() => process.exit(0));
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main();
+`.trim();
+}
+function generateStandardHandlerEntry() {
+	return `// Auto-generated ubean standard fetch handler
+import createFetchHandler from './entry.mjs';
+
+const handlerPromise = createFetchHandler();
+export default async function fetch(req, ctx) {
+  const handler = await handlerPromise;
+  return handler(req, ctx);
+}
+`.trim();
+}
+function generateCloudflareWorkerEntry() {
+	return `// Auto-generated ubean Cloudflare Worker entry
+import createFetchHandler from './entry.mjs';
+
+const handlerPromise = createFetchHandler();
+export default {
+  async fetch(req, env, ctx) {
+    const handler = await handlerPromise;
+    return handler(req, { ...ctx, env });
+  }
+};
+`.trim();
+}
+async function buildProduction(options) {
+	const { cwd, config, preset, scanResult, minify = true, sourcemap = false } = options;
+	const outDirs = getOutDirs(cwd, config.build.outputDir);
+	const srcDir = resolve(cwd, config.srcDir);
+	const mode = config.mode;
+	const ssrEnabled = mode === "fullstack" && config.ssr || mode === "ssg";
+	const hasPages = mode !== "backend";
+	const hasServer = mode !== "spa";
+	logger.info(`Cleaning output directory... (mode=${mode}${mode === "fullstack" ? `, ssr=${config.ssr}` : ""})`);
+	if (existsSync(outDirs.root)) await rm(outDirs.root, {
+		recursive: true,
+		force: true
+	});
+	if (hasPages) await mkdir(outDirs.public, { recursive: true });
+	if (hasServer) await mkdir(outDirs.server, { recursive: true });
+	logger.info("Generating virtual modules...");
+	await generateVirtualModulesToDisk(cwd, config, scanResult, outDirs.virtual);
+	const userViteConfig = findUserViteConfig(cwd);
+	const builtinPlugins = [];
+	if (hasPages) builtinPlugins.push(vue({
+		include: VUE_PLUGIN_INCLUDE,
+		template: { compilerOptions: { isCustomElement: (tag) => tag.startsWith("ubean-") } }
+	}));
+	if (!userViteConfig) {
+		builtinPlugins.push(ubeanPlugin({ config }));
+		if (hasPages) builtinPlugins.push(...ubeanVuePlugin({ config }), ubeanIslandsPlugin());
+	}
+	const { plugins } = await resolveModules({
+		cwd,
+		config,
+		builtinPlugins
+	});
+	const presetBuildConfig = getPresetBuildConfig(preset);
+	const virtualDir = outDirs.virtual;
+	const commonResolve = { alias: {
+		"virtual:ubean-pages": join(virtualDir, "vue-pages.ts"),
+		"virtual:ubean-app": join(virtualDir, "vue-app.ts"),
+		"virtual:ubean-server": join(virtualDir, "server-entry.ts"),
+		"virtual:ubean-client-entry": join(virtualDir, "client-entry.mjs"),
+		"#ubean-pages": join(virtualDir, "vue-pages.ts"),
+		"#ubean-app": join(virtualDir, "vue-app.ts"),
+		"#ubean-server": join(virtualDir, "server-entry.ts"),
+		"#ubean-client-entry": join(virtualDir, "client-entry.mjs"),
+		"ubean:pages": join(virtualDir, "pages.ts"),
+		"ubean:routes": join(virtualDir, "routes.mjs"),
+		"ubean:app-config": join(virtualDir, "app-config.mjs"),
+		"ubean:locales": join(virtualDir, "locales.mjs"),
+		"ubean:meta": join(virtualDir, "meta.mjs")
+	} };
+	let clientManifest = {};
+	if (hasPages) {
+		logger.info("Building client bundle...");
+		const clientEntryPath = join(srcDir, "entry.client.ts");
+		const clientInput = existsSync(clientEntryPath) ? clientEntryPath : join(virtualDir, "client-entry.mjs");
+		await writeFile(join(virtualDir, "index.html"), `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="icon" href="/favicon.svg" type="image/svg+xml" />
+  <title>Ubean App</title>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="virtual:ubean-client-entry"><\/script>
+</body>
+</html>`, "utf-8");
+		await build({
+			root: cwd,
+			configFile: userViteConfig ?? false,
+			mode: "production",
+			build: {
+				outDir: outDirs.public,
+				assetsDir: "assets",
+				minify: minify ? "oxc" : false,
+				sourcemap,
+				manifest: true,
+				ssrManifest: true,
+				rollupOptions: {
+					input: { app: clientInput },
+					output: {
+						entryFileNames: "assets/[name]-[hash].js",
+						chunkFileNames: "assets/chunks/[name]-[hash].js",
+						assetFileNames: "assets/[name]-[hash].[ext]"
+					}
+				},
+				emptyOutDir: false
+			},
+			plugins: [...plugins],
+			resolve: commonResolve,
+			optimizeDeps: { exclude: [
+				"ubean",
+				"virtual:ubean-pages",
+				"virtual:ubean-app",
+				"virtual:ubean-server",
+				"virtual:ubean-client-entry",
+				"#ubean-pages",
+				"#ubean-app",
+				"#ubean-server",
+				"#ubean-client-entry"
+			] }
+		});
+		const manifestPath = join(outDirs.public, ".vite", "manifest.json");
+		if (existsSync(manifestPath)) try {
+			clientManifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+		} catch {}
+		const publicDir = join(cwd, "public");
+		if (existsSync(publicDir)) {
+			logger.info("Copying public assets...");
+			await cp(publicDir, outDirs.public, { recursive: true });
+		}
+	}
+	let serverEntry = "";
+	if (hasServer) {
+		logger.info(ssrEnabled ? "Building SSR bundle..." : "Building server bundle (SSR disabled)...");
+		const serverEntryPath = join(virtualDir, "server-entry.mjs");
+		await build({
+			root: cwd,
+			configFile: userViteConfig ?? false,
+			mode: "production",
+			ssr: {
+				target: presetBuildConfig.target === "node18" ? "node" : "webworker",
+				noExternal: ["ubean"]
+			},
+			build: {
+				outDir: outDirs.server,
+				ssr: true,
+				minify: false,
+				sourcemap,
+				rollupOptions: {
+					input: serverEntryPath,
+					external: presetBuildConfig.external,
+					output: {
+						format: presetBuildConfig.format,
+						entryFileNames: "entry.mjs",
+						chunkFileNames: "chunks/[name]-[hash].mjs",
+						inlineDynamicImports: presetBuildConfig.entryType === "worker"
+					}
+				},
+				emptyOutDir: false
+			},
+			plugins: [...plugins],
+			resolve: commonResolve
+		});
+		serverEntry = "entry.mjs";
+		if (presetBuildConfig.entryType === "node") {
+			await writeFile(join(outDirs.server, "server.mjs"), generateNodeServerEntry(), "utf-8");
+			serverEntry = "server.mjs";
+			await writeFile(join(outDirs.server, "package.json"), JSON.stringify({
+				type: "module",
+				private: true,
+				main: "./server.mjs",
+				dependencies: { hono: "^4.0.0" }
+			}, null, 2), "utf-8");
+		} else if (presetBuildConfig.entryType === "worker") {
+			await writeFile(join(outDirs.server, "worker.mjs"), generateCloudflareWorkerEntry(), "utf-8");
+			serverEntry = "worker.mjs";
+			const wranglerToml = `
+name = "ubean-app"
+main = "./server/worker.mjs"
+compatibility_date = "2024-01-01"
+assets = { directory = "./public" }
+`.trim();
+			await writeFile(join(outDirs.root, "wrangler.toml"), wranglerToml, "utf-8");
+		} else {
+			await writeFile(join(outDirs.server, "handler.mjs"), generateStandardHandlerEntry(), "utf-8");
+			serverEntry = "handler.mjs";
+		}
+	}
+	const assets = [];
+	for (const [key, entry] of Object.entries(clientManifest)) assets.push({
+		file: entry.file,
+		src: key,
+		isEntry: entry.isEntry,
+		css: entry.css
+	});
+	const manifest = {
+		assets,
+		entry: serverEntry,
+		clientDir: hasPages ? relative(cwd, outDirs.public) : "",
+		serverDir: hasServer ? relative(cwd, outDirs.server) : "",
+		preset: preset.name || "standard"
+	};
+	await writeFile(join(outDirs.root, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+	logger.success(`Build complete! Output: ${outDirs.root}`);
+	if (hasPages) logger.info(`  Client assets: ${outDirs.public}`);
+	if (hasServer) {
+		logger.info(`  Server bundle: ${outDirs.server}`);
+		logger.info(`  Entry: ${serverEntry}`);
+	}
+	return manifest;
+}
+//#endregion
+export { buildProduction };