@teamvelix/velix 5.0.1 → 5.0.3

package/dist/server/index.js

@@ -22,8 +22,8 @@ var image_optimizer_exports = {};
 __export(image_optimizer_exports, {
   handleImageOptimization: () => handleImageOptimization
 });
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 async function handleImageOptimization(req, res, projectRoot) {
   let sharp;
   try {
@@ -48,14 +48,14 @@ async function handleImageOptimization(req, res, projectRoot) {
       if (!response.ok) throw new Error(`Failed to fetch ${imageUrl}`);
       imageBuffer = Buffer.from(await response.arrayBuffer());
     } else {
-      const publicDir = path6.join(projectRoot, "public");
-      const resolvedPath = path6.join(publicDir, imageUrl.startsWith("/") ? imageUrl.slice(1) : imageUrl);
-      if (!resolvedPath.startsWith(publicDir) || !fs6.existsSync(resolvedPath)) {
+      const publicDir = path7.join(projectRoot, "public");
+      const resolvedPath = path7.join(publicDir, imageUrl.startsWith("/") ? imageUrl.slice(1) : imageUrl);
+      if (!resolvedPath.startsWith(publicDir) || !fs7.existsSync(resolvedPath)) {
         res.writeHead(404);
         res.end("Image not found");
         return;
       }
-      imageBuffer = fs6.readFileSync(resolvedPath);
+      imageBuffer = fs7.readFileSync(resolvedPath);
     }
     if (!sharp) {
       res.writeHead(200, {
@@ -92,8 +92,8 @@ var init_image_optimizer = __esm({
 // server/index.ts
 init_esm_shims();
 import http from "http";
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "url";
 import React2 from "react";
 import { renderToString } from "react-dom/server";
@@ -682,6 +682,8 @@ var builtinPlugins = {
 // plugins/tailwind.ts
 init_esm_shims();
 import { spawnSync, spawn } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
 
 // logger.ts
 init_esm_shims();
@@ -733,14 +735,14 @@ var logger = {
     if (pagesDir) console.log(`  ${c.bold}App:${c.reset}        ${c.dim}${pagesDir}${c.reset}`);
     console.log("");
   },
-  request(method, path8, status, time, extra = {}) {
+  request(method, path9, status, time, extra = {}) {
     const statusColor = getStatusColor(status);
     const timeStr = fmtTime(time);
     let badge = `${c.dim}\u25CB${c.reset}`;
     if (extra.type === "dynamic" || extra.type === "ssr") badge = `${c.white}\u0192${c.reset}`;
     else if (extra.type === "api") badge = `${c.cyan}\u03BB${c.reset}`;
     const statusStr = `${statusColor}${status}${c.reset}`;
-    console.log(`  ${badge} ${c.white}${method}${c.reset} ${path8} ${statusStr} ${c.dim}${timeStr}${c.reset}`);
+    console.log(`  ${badge} ${c.white}${method}${c.reset} ${path9} ${statusStr} ${c.dim}${timeStr}${c.reset}`);
   },
   info(msg) {
     console.log(`  ${c.cyan}\u2139${c.reset} ${msg}`);
@@ -768,10 +770,10 @@ var logger = {
   plugin(name) {
     console.log(`  ${c.cyan}\u25C6${c.reset} Plugin ${c.dim}${name}${c.reset}`);
   },
-  route(path8, type) {
+  route(path9, type) {
     const typeLabel = type === "api" ? "\u03BB" : type === "dynamic" ? "\u0192" : "\u25CB";
     const color = type === "api" ? c.cyan : type === "dynamic" ? c.white : c.dim;
-    console.log(`  ${color}${typeLabel}${c.reset} ${path8}`);
+    console.log(`  ${color}${typeLabel}${c.reset} ${path9}`);
   },
   divider() {
     console.log(`${c.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
@@ -829,20 +831,68 @@ function tailwindPlugin(options = {}) {
       },
       [PluginHooks.SERVER_START]: async (server, isDev) => {
         if (!isDev) return;
+        if (!fs6.existsSync(input)) {
+          logger_default.warn(`Tailwind input file not found: ${input}`);
+          return;
+        }
+        const outputDir = path6.dirname(output);
+        if (!fs6.existsSync(outputDir)) {
+          fs6.mkdirSync(outputDir, { recursive: true });
+        }
+        logger_default.info("Building initial Tailwind CSS...");
+        try {
+          const buildResult = spawnSync("npx", ["tailwindcss", "-i", input, "-o", output], {
+            cwd: process.cwd(),
+            stdio: "pipe"
+          });
+          if (buildResult.error) {
+            logger_default.error("Tailwind CSS not installed. Run: npm install -D tailwindcss");
+            return;
+          }
+          if (buildResult.status !== 0) {
+            const errorMsg = buildResult.stderr?.toString() || "Unknown error";
+            logger_default.error(`Tailwind build failed: ${errorMsg}`);
+            return;
+          }
+          logger_default.success("Tailwind CSS built successfully");
+        } catch (err) {
+          logger_default.error("Failed to build Tailwind CSS", err);
+          return;
+        }
         logger_default.info("Starting Tailwind CSS watcher...");
         const watcher = spawn("npx", ["tailwindcss", "-i", input, "-o", output, "--watch"], {
           stdio: "pipe",
-          cwd: process.cwd()
+          cwd: process.cwd(),
+          shell: false
         });
         watcher.stdout.on("data", (data) => {
           const msg = data.toString().trim();
-          if (msg && !msg.includes("Rebuilding...")) {
+          if (msg && !msg.includes("Rebuilding...") && !msg.includes("Done in")) {
+            logger_default.info(`Tailwind: ${msg}`);
+          }
+        });
+        watcher.stderr.on("data", (data) => {
+          const msg = data.toString().trim();
+          if (msg && !msg.includes("warn")) {
+            logger_default.warn(`Tailwind: ${msg}`);
           }
         });
         watcher.on("error", (err) => {
           logger_default.error("Tailwind watcher error", err);
         });
-        process.on("exit", () => watcher.kill());
+        watcher.on("exit", (code) => {
+          if (code !== 0 && code !== null) {
+            logger_default.error(`Tailwind watcher exited with code ${code}`);
+          }
+        });
+        const cleanup = () => {
+          if (watcher && !watcher.killed) {
+            watcher.kill();
+          }
+        };
+        process.on("exit", cleanup);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
       }
     }
   });
@@ -2017,7 +2067,7 @@ async function createServer(options = {}) {
   await loadPlugins(projectRoot, config);
   await pluginManager.runHook(PluginHooks.CONFIG, config);
   const middlewareFns = await loadMiddleware(projectRoot);
-  const appDir = config.resolvedAppDir || path7.join(projectRoot, "app");
+  const appDir = config.resolvedAppDir || path8.join(projectRoot, "app");
   const routes = buildRouteTree(appDir);
   await pluginManager.runHook(PluginHooks.ROUTES_LOADED, routes);
   const startTime = Date.now();
@@ -2059,7 +2109,7 @@ async function createServer(options = {}) {
         await serveVelixInternal(pathname, req, res, projectRoot);
         return;
       }
-      const publicDir = config.resolvedPublicDir || path7.join(projectRoot, "public");
+      const publicDir = config.resolvedPublicDir || path8.join(projectRoot, "public");
       if (await serveStaticFile(pathname, publicDir, res, isDev)) {
         if (isDev) logger_default.request(req.method || "GET", pathname, 200, Date.now() - requestStart, { type: "static" });
         return;
@@ -2128,12 +2178,12 @@ async function createServer(options = {}) {
   };
 }
 async function serveStaticFile(pathname, publicDir, res, isDev = false) {
-  const filePath = path7.join(publicDir, pathname);
+  const filePath = path8.join(publicDir, pathname);
   if (!filePath.startsWith(publicDir)) return false;
-  if (!fs7.existsSync(filePath) || fs7.statSync(filePath).isDirectory()) return false;
-  const ext = path7.extname(filePath);
+  if (!fs8.existsSync(filePath) || fs8.statSync(filePath).isDirectory()) return false;
+  const ext = path8.extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
-  const content = fs7.readFileSync(filePath);
+  const content = fs8.readFileSync(filePath);
   res.writeHead(200, {
     "Content-Type": contentType,
     "Content-Length": content.length,
@@ -2213,8 +2263,8 @@ async function handlePageRoute(route, routes, req, res, url, config, isDev, proj
     let LayoutComponent = ({ children }) => React2.createElement(React2.Fragment, null, children);
     let layoutParams = route.params;
     try {
-      const layoutPath = path7.join(path7.dirname(route.filePath), "layout.tsx");
-      if (fs7.existsSync(layoutPath)) {
+      const layoutPath = path8.join(path8.dirname(route.filePath), "layout.tsx");
+      if (fs8.existsSync(layoutPath)) {
         const layoutMod = await import(`${pathToFileURL3(layoutPath).href}?t=${Date.now()}`);
         if (layoutMod.metadata) {
           metadata = { ...layoutMod.metadata, ...metadata };
@@ -2334,12 +2384,12 @@ async function serveVelixInternal(pathname, req, res, projectRoot) {
   }
   if (pathname === "/__velix/logo.webp") {
     const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = path7.dirname(__filename2);
-    const fallbackPath = path7.join(path7.dirname(pathToFileURL3(__dirname2).pathname), "..", "assets", "logo.webp");
-    const logoPath = fs7.existsSync(fallbackPath) ? fallbackPath : path7.join(process.cwd(), "node_modules", "velix", "assets", "logo.webp");
-    if (fs7.existsSync(logoPath)) {
+    const __dirname2 = path8.dirname(__filename2);
+    const fallbackPath = path8.join(path8.dirname(pathToFileURL3(__dirname2).pathname), "..", "assets", "logo.webp");
+    const logoPath = fs8.existsSync(fallbackPath) ? fallbackPath : path8.join(process.cwd(), "node_modules", "velix", "assets", "logo.webp");
+    if (fs8.existsSync(logoPath)) {
       res.writeHead(200, { "Content-Type": "image/webp", "Cache-Control": "public, max-age=31536000, immutable" });
-      res.end(fs7.readFileSync(logoPath));
+      res.end(fs8.readFileSync(logoPath));
     } else {
       res.writeHead(404);
       res.end();
@@ -2350,17 +2400,17 @@ async function serveVelixInternal(pathname, req, res, projectRoot) {
     const componentName = pathname.replace("/__velix/islands/", "").replace(".js", "");
     try {
       const searchDirs = [
-        path7.join(projectRoot, "components"),
-        path7.join(projectRoot, "app"),
-        path7.join(projectRoot, "islands")
+        path8.join(projectRoot, "components"),
+        path8.join(projectRoot, "app"),
+        path8.join(projectRoot, "islands")
       ];
       let componentPath = "";
       for (const dir of searchDirs) {
-        if (!fs7.existsSync(dir)) continue;
-        const files = fs7.readdirSync(dir, { recursive: true });
+        if (!fs8.existsSync(dir)) continue;
+        const files = fs8.readdirSync(dir, { recursive: true });
         const found = files.find((f) => f.replace(/\\/g, "/").endsWith(`${componentName}.tsx`) || f.replace(/\\/g, "/").endsWith(`${componentName}.jsx`));
         if (found) {
-          componentPath = path7.join(dir, found);
+          componentPath = path8.join(dir, found);
           break;
         }
       }