olova 2.0.55 → 2.0.56

package/dist/plugin.js

@@ -1,894 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/ssg/crawler.ts
-import fs from "fs";
-import path from "path";
-async function crawlRoutes(config) {
-  const appPath = path.resolve(config.root, config.appDir);
-  if (!fs.existsSync(appPath)) {
-    console.warn(`[olova-ssg] App directory not found: ${appPath}`);
-    return [];
-  }
-  const pages = [];
-  await scanDirectory(appPath, "/", config, pages);
-  return pages;
-}
-async function scanDirectory(dir, routePath, config, pages) {
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const segment = entry.name;
-      if (segment.startsWith("(") && segment.endsWith(")")) {
-        await scanDirectory(fullPath, routePath, config, pages);
-        continue;
-      }
-      if (segment.startsWith("@")) {
-        continue;
-      }
-      if (segment.startsWith("[")) {
-        const newRoutePath2 = buildDynamicRoutePath(routePath, segment);
-        await scanDirectory(fullPath, newRoutePath2, config, pages);
-        continue;
-      }
-      const newRoutePath = routePath === "/" ? `/${segment}` : `${routePath}/${segment}`;
-      await scanDirectory(fullPath, newRoutePath, config, pages);
-    } else if (entry.isFile()) {
-      const isPage = config.extensions.some((ext) => entry.name === `page${ext}`);
-      if (isPage) {
-        const isDynamicRoute = routePath.includes(":") || routePath.includes("*");
-        const { metadata, hasGenerateMetadata } = await extractPageMetadata(fullPath);
-        pages.push({
-          path: routePath || "/",
-          componentPath: fullPath,
-          isStatic: !isDynamicRoute,
-          params: {},
-          metadata,
-          hasGenerateMetadata
-        });
-      }
-    }
-  }
-}
-function buildDynamicRoutePath(basePath, segment) {
-  let pathSegment;
-  if (segment.startsWith("[[...") && segment.endsWith("]]")) {
-    const paramName = segment.slice(5, -2);
-    pathSegment = `:${paramName}*`;
-  } else if (segment.startsWith("[...") && segment.endsWith("]")) {
-    const paramName = segment.slice(4, -1);
-    pathSegment = `:${paramName}*`;
-  } else if (segment.startsWith("[") && segment.endsWith("]")) {
-    const paramName = segment.slice(1, -1);
-    pathSegment = `:${paramName}`;
-  } else {
-    pathSegment = segment;
-  }
-  return basePath === "/" ? `/${pathSegment}` : `${basePath}/${pathSegment}`;
-}
-async function extractPageMetadata(filePath) {
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const hasGenerateMetadata = /export\s+(async\s+)?function\s+generateMetadata/.test(content);
-    const metadataMatch = content.match(/export\s+const\s+metadata\s*=\s*(\{[\s\S]*?\n\};?)/);
-    if (metadataMatch) {
-      try {
-        const metadataStr = metadataMatch[1];
-        const metadata = Function('"use strict"; return (' + metadataStr + ")")();
-        return { metadata, hasGenerateMetadata };
-      } catch {
-        return { metadata: extractMetadataSimple(content), hasGenerateMetadata };
-      }
-    }
-    return { metadata: null, hasGenerateMetadata };
-  } catch (e) {
-    console.warn(`[olova-ssg] Failed to extract metadata from ${filePath}`);
-    return { metadata: null, hasGenerateMetadata: false };
-  }
-}
-function extractMetadataSimple(content) {
-  const metadata = {};
-  const titleMatch = content.match(/title:\s*['"`]([^'"`]+)['"`]/);
-  if (titleMatch) metadata.title = titleMatch[1];
-  const descMatch = content.match(/description:\s*['"`]([^'"`]+)['"`]/);
-  if (descMatch) metadata.description = descMatch[1];
-  const keywordsMatch = content.match(/keywords:\s*\[([^\]]+)\]/);
-  if (keywordsMatch) {
-    const keywords = keywordsMatch[1].split(",").map((k) => k.trim().replace(/['"`]/g, "")).filter(Boolean);
-    if (keywords.length) metadata.keywords = keywords;
-  }
-  return Object.keys(metadata).length > 0 ? metadata : null;
-}
-function getStaticPages(pages) {
-  return pages.filter((page) => page.isStatic);
-}
-function getDynamicPages(pages) {
-  return pages.filter((page) => !page.isStatic);
-}
-var init_crawler = __esm({
-  "src/ssg/crawler.ts"() {
-    "use strict";
-  }
-});
-
-// src/ssg/generator.ts
-import fs2 from "fs";
-import path2 from "path";
-function generateSSREntry(pages, config) {
-  const entryPath = path2.resolve(config.root, ".olova-ssg-entry.tsx");
-  const imports = [];
-  const routeMap = [];
-  const appDir = path2.resolve(config.root, config.appDir);
-  const layoutPath = findLayoutFile(appDir, config.extensions);
-  if (layoutPath) {
-    const relativePath = path2.relative(config.root, layoutPath).replace(/\\/g, "/");
-    imports.push(`import Layout from './${relativePath}';`);
-  }
-  pages.forEach((page, index) => {
-    const relativePath = path2.relative(config.root, page.componentPath).replace(/\\/g, "/");
-    imports.push(`import Page${index} from './${relativePath}';`);
-    routeMap.push(`  '${page.path}': Page${index},`);
-  });
-  const entryContent = `
-// Auto-generated SSR entry for Olova SSG
-import React from 'react';
-import { renderToString } from 'react-dom/server';
-import { setSSRContext } from 'olova';
-
-${imports.join("\n")}
-
-const routeComponents: Record<string, React.ComponentType<any>> = {
-${routeMap.join("\n")}
-};
-
-export async function render(routePath: string, params: Record<string, string> = {}) {
-  const Component = routeComponents[routePath];
-  
-  if (!Component) {
-    console.warn('[olova-ssg] No component found for route:', routePath);
-    return '';
-  }
-  
-  try {
-    // Set the SSR context before rendering
-    setSSRContext(routePath, params);
-    
-    // Build component hierarchy
-    const pageElement = React.createElement(Component, { params, searchParams: {} });
-    ${layoutPath ? `const element = React.createElement(Layout, { children: pageElement, params });` : `const element = pageElement;`}
-    
-    return renderToString(element);
-  } catch (error: any) {
-    console.error('[olova-ssg] SSR Error for', routePath, ':', error.message);
-    throw error;
-  }
-}
-
-export const routes = ${JSON.stringify(pages.map((p) => ({ path: p.path, isStatic: p.isStatic })), null, 2)};
-`;
-  fs2.writeFileSync(entryPath, entryContent, "utf-8");
-  return entryPath;
-}
-function findLayoutFile(dir, extensions) {
-  for (const ext of extensions) {
-    const layoutPath = path2.join(dir, `layout${ext}`);
-    if (fs2.existsSync(layoutPath)) {
-      return layoutPath;
-    }
-  }
-  return null;
-}
-function cleanupSSREntry(entryPath) {
-  try {
-    if (fs2.existsSync(entryPath)) {
-      fs2.unlinkSync(entryPath);
-    }
-  } catch (e) {
-    console.warn("[olova-ssg] Failed to cleanup SSR entry file");
-  }
-}
-function generateHydrationScript(routePath, params) {
-  return `
-<script>
-  window.__OLOVA_DATA__ = ${JSON.stringify({ route: routePath, params, hydrated: false })};
-</script>
-`;
-}
-var init_generator = __esm({
-  "src/ssg/generator.ts"() {
-    "use strict";
-  }
-});
-
-// src/ssg/renderer.ts
-import fs3 from "fs";
-import path3 from "path";
-import { pathToFileURL } from "url";
-import { build as viteBuild } from "vite";
-async function renderPage(page, config, ssrEntryPath) {
-  const tempSSRDir = path3.join(config.root, ".olova", "ssr");
-  if (!fs3.existsSync(tempSSRDir)) {
-    fs3.mkdirSync(tempSSRDir, { recursive: true });
-  }
-  const pkgPath = path3.join(tempSSRDir, "package.json");
-  if (!fs3.existsSync(pkgPath)) {
-    fs3.writeFileSync(pkgPath, JSON.stringify({ type: "module" }));
-  }
-  const outputFileName = `ssr-entry-${Date.now()}.js`;
-  const outputPath = path3.join(tempSSRDir, outputFileName);
-  try {
-    await viteBuild({
-      configFile: false,
-      root: config.root,
-      logLevel: "silent",
-      build: {
-        ssr: true,
-        write: true,
-        outDir: tempSSRDir,
-        emptyOutDir: false,
-        rollupOptions: {
-          input: ssrEntryPath,
-          output: {
-            format: "esm",
-            entryFileNames: outputFileName
-          },
-          onwarn: (warning, handler) => {
-            if (warning.code === "MODULE_LEVEL_DIRECTIVE") return;
-            handler(warning);
-          }
-        }
-      },
-      plugins: [
-        {
-          name: "olova-ssr-transforms",
-          transform(code) {
-            return code.replace(/['"]use client['"];?/g, "").replace(/['"]use static['"];?/g, "");
-          }
-        }
-      ]
-    });
-    if (fs3.existsSync(outputPath)) {
-      const moduleUrl = pathToFileURL(outputPath).href;
-      const mod = await import(moduleUrl);
-      const content = await mod.render(page.path, page.params);
-      return {
-        content: content || "",
-        metadata: page.metadata
-      };
-    }
-    throw new Error("Built SSR artifact not found");
-  } finally {
-    if (fs3.existsSync(outputPath)) {
-      try {
-        fs3.unlinkSync(outputPath);
-      } catch {
-      }
-    }
-  }
-}
-async function renderPages(pages, config, ssrEntryPath, onProgress) {
-  const results = /* @__PURE__ */ new Map();
-  for (let i = 0; i < pages.length; i++) {
-    const page = pages[i];
-    if (onProgress) {
-      onProgress(page, i, pages.length);
-    }
-    try {
-      const result = await renderPage(page, config, ssrEntryPath);
-      results.set(page.path, result);
-    } catch (error) {
-      console.error(`[olova-ssg] Failed to render ${page.path}:`, error.message);
-      results.set(page.path, { content: "", metadata: page.metadata });
-    }
-  }
-  return results;
-}
-var init_renderer = __esm({
-  "src/ssg/renderer.ts"() {
-    "use strict";
-  }
-});
-
-// src/ssg/html.ts
-import fs4 from "fs";
-import path4 from "path";
-function generateHTML(options) {
-  const {
-    content,
-    jsEntry,
-    cssEntries,
-    metadata,
-    routePath,
-    params
-  } = options;
-  const metaTags = metadata ? generateMetaTags(metadata) : "";
-  const cssLinks = cssEntries.map((css) => `<link rel="stylesheet" href="${css}">`).join("\n    ");
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${metaTags}
-    ${cssLinks}
-  </head>
-  <body>
-    <div id="root">${content}</div>
-    <script>
-      window.__OLOVA_DATA__ = ${JSON.stringify({ route: routePath, params, hydrated: false })};
-    </script>
-    ${jsEntry ? `<script type="module" src="${jsEntry}"></script>` : ""}
-  </body>
-</html>`;
-}
-function generateMetaTags(metadata) {
-  const tags = [];
-  if (metadata.title) {
-    tags.push(`<title>${escapeHtml(metadata.title)}</title>`);
-  }
-  if (metadata.description) {
-    tags.push(`<meta name="description" content="${escapeHtml(metadata.description)}" />`);
-  }
-  if (metadata.keywords?.length) {
-    tags.push(`<meta name="keywords" content="${escapeHtml(metadata.keywords.join(", "))}" />`);
-  }
-  if (metadata.robots) {
-    tags.push(`<meta name="robots" content="${escapeHtml(metadata.robots)}" />`);
-  }
-  if (metadata.canonical) {
-    tags.push(`<link rel="canonical" href="${escapeHtml(metadata.canonical)}" />`);
-  }
-  if (metadata.openGraph) {
-    const og = metadata.openGraph;
-    if (og.title) {
-      tags.push(`<meta property="og:title" content="${escapeHtml(og.title)}" />`);
-    }
-    if (og.description) {
-      tags.push(`<meta property="og:description" content="${escapeHtml(og.description)}" />`);
-    }
-    if (og.url) {
-      tags.push(`<meta property="og:url" content="${escapeHtml(og.url)}" />`);
-    }
-    if (og.siteName) {
-      tags.push(`<meta property="og:site_name" content="${escapeHtml(og.siteName)}" />`);
-    }
-    if (og.type) {
-      tags.push(`<meta property="og:type" content="${og.type}" />`);
-    }
-    if (og.images?.length) {
-      for (const image of og.images) {
-        tags.push(`<meta property="og:image" content="${escapeHtml(image.url)}" />`);
-        if (image.width) {
-          tags.push(`<meta property="og:image:width" content="${image.width}" />`);
-        }
-        if (image.height) {
-          tags.push(`<meta property="og:image:height" content="${image.height}" />`);
-        }
-        if (image.alt) {
-          tags.push(`<meta property="og:image:alt" content="${escapeHtml(image.alt)}" />`);
-        }
-      }
-    }
-  }
-  if (metadata.twitter) {
-    const tw = metadata.twitter;
-    if (tw.card) {
-      tags.push(`<meta name="twitter:card" content="${tw.card}" />`);
-    }
-    if (tw.title) {
-      tags.push(`<meta name="twitter:title" content="${escapeHtml(tw.title)}" />`);
-    }
-    if (tw.description) {
-      tags.push(`<meta name="twitter:description" content="${escapeHtml(tw.description)}" />`);
-    }
-    if (tw.creator) {
-      tags.push(`<meta name="twitter:creator" content="${escapeHtml(tw.creator)}" />`);
-    }
-    if (tw.site) {
-      tags.push(`<meta name="twitter:site" content="${escapeHtml(tw.site)}" />`);
-    }
-    if (tw.images?.length) {
-      tags.push(`<meta name="twitter:image" content="${escapeHtml(tw.images[0])}" />`);
-    }
-  }
-  if (metadata.authors?.length) {
-    for (const author of metadata.authors) {
-      tags.push(`<meta name="author" content="${escapeHtml(author.name)}" />`);
-    }
-  }
-  return tags.join("\n    ");
-}
-function discoverBuildAssets(distDir) {
-  let jsEntry = "";
-  const cssEntries = [];
-  const assetsDir = path4.join(distDir, "assets");
-  if (fs4.existsSync(assetsDir)) {
-    const assets = fs4.readdirSync(assetsDir);
-    for (const asset of assets) {
-      if (asset.startsWith("index") && asset.endsWith(".js")) {
-        jsEntry = `/assets/${asset}`;
-      } else if (asset.endsWith(".css")) {
-        cssEntries.push(`/assets/${asset}`);
-      }
-    }
-  }
-  return { jsEntry, cssEntries };
-}
-function injectContentIntoHTML(baseHtml, content, metadata) {
-  let html = baseHtml;
-  html = html.replace(
-    /<div id="root"[^>]*>[\s\S]*?<\/div>/,
-    `<div id="root">${content}</div>`
-  );
-  if (metadata) {
-    const metaTags = generateMetaTags(metadata);
-    if (metadata.title) {
-      html = html.replace(/<title>[^<]*<\/title>/g, "");
-    }
-    if (metadata.description) {
-      html = html.replace(/<meta\s+name="description"[^>]*>/g, "");
-    }
-    if (metadata.openGraph) {
-      html = html.replace(/<meta\s+property="og:[^"]*"[^>]*>/g, "");
-    }
-    if (metadata.twitter) {
-      html = html.replace(/<meta\s+name="twitter:[^"]*"[^>]*>/g, "");
-    }
-    html = html.replace(/<head>/, `<head>
-    ${metaTags}`);
-  }
-  return html;
-}
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function generateSitemap(pages, siteUrl) {
-  const urls = pages.map((page) => `  <url>
-    <loc>${siteUrl}${page.path === "/" ? "" : page.path}</loc>
-    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
-    <changefreq>daily</changefreq>
-    <priority>${page.path === "/" ? "1.0" : "0.8"}</priority>
-  </url>`).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls}
-</urlset>`;
-}
-function generateRobotsTxt(siteUrl) {
-  return `User-agent: *
-Allow: /
-
-Sitemap: ${siteUrl}/sitemap.xml`;
-}
-var init_html = __esm({
-  "src/ssg/html.ts"() {
-    "use strict";
-  }
-});
-
-// src/ssg/prerender.ts
-import fs5 from "fs";
-import path5 from "path";
-async function runSSG(config) {
-  const startTime = Date.now();
-  const failedPages = [];
-  console.log("\n\u{1F4E6} Olova SSG - Starting static generation...\n");
-  console.log("\u{1F50D} Discovering routes...");
-  const allPages = await crawlRoutes(config);
-  const staticPages = getStaticPages(allPages);
-  console.log(`   Found ${allPages.length} total routes`);
-  console.log(`   ${staticPages.length} static routes will be pre-rendered
-`);
-  if (staticPages.length === 0) {
-    console.log("\u26A0\uFE0F  No static pages found to pre-render\n");
-    return {
-      totalPages: allPages.length,
-      staticPages: 0,
-      failedPages: [],
-      duration: Date.now() - startTime
-    };
-  }
-  console.log("\u{1F4DD} Generating SSR entry...");
-  const ssrEntryPath = generateSSREntry(staticPages, config);
-  const distDir = path5.resolve(config.root, config.outDir);
-  const { jsEntry, cssEntries } = discoverBuildAssets(distDir);
-  console.log(`   JS entry: ${jsEntry || "(none)"}`);
-  console.log(`   CSS files: ${cssEntries.length}
-`);
-  const baseHtmlPath = path5.join(distDir, "index.html");
-  let baseHtml = "";
-  if (fs5.existsSync(baseHtmlPath)) {
-    baseHtml = fs5.readFileSync(baseHtmlPath, "utf-8");
-  } else {
-    console.warn("\u26A0\uFE0F  No index.html found in dist, generating from scratch");
-  }
-  console.log("\u{1F528} Pre-rendering pages...\n");
-  for (const page of staticPages) {
-    const pageStartTime = Date.now();
-    try {
-      const result = await renderPage(page, config, ssrEntryPath);
-      const outputPath = page.path === "/" ? path5.join(distDir, "index.html") : path5.join(distDir, page.path, "index.html");
-      const outputDir = path5.dirname(outputPath);
-      if (!fs5.existsSync(outputDir)) {
-        fs5.mkdirSync(outputDir, { recursive: true });
-      }
-      let html;
-      if (baseHtml) {
-        html = injectContentIntoHTML(baseHtml, result.content, result.metadata);
-      } else {
-        html = generateHTML({
-          content: result.content,
-          jsEntry,
-          cssEntries,
-          metadata: result.metadata,
-          routePath: page.path,
-          params: page.params
-        });
-      }
-      if (!html.includes("__OLOVA_DATA__")) {
-        html = html.replace(
-          "</body>",
-          `<script>window.__OLOVA_DATA__ = ${JSON.stringify({ route: page.path, params: page.params, hydrated: false })};</script>
-</body>`
-        );
-      }
-      fs5.writeFileSync(outputPath, html, "utf-8");
-      const duration2 = Date.now() - pageStartTime;
-      console.log(`   \u2705 ${page.path} (${duration2}ms)`);
-    } catch (error) {
-      failedPages.push(page.path);
-      console.log(`   \u274C ${page.path} - ${error.message}`);
-    }
-  }
-  console.log("\n\u{1F4C4} Generating SEO files...");
-  const siteUrl = "https://example.com";
-  const sitemap = generateSitemap(staticPages, siteUrl);
-  fs5.writeFileSync(path5.join(distDir, "sitemap.xml"), sitemap, "utf-8");
-  console.log("   \u2705 sitemap.xml");
-  const robotsPath = path5.join(distDir, "robots.txt");
-  if (!fs5.existsSync(robotsPath)) {
-    fs5.writeFileSync(robotsPath, generateRobotsTxt(siteUrl), "utf-8");
-    console.log("   \u2705 robots.txt");
-  }
-  cleanupSSREntry(ssrEntryPath);
-  const buildManifest = {
-    version: Date.now().toString(36),
-    buildTime: (/* @__PURE__ */ new Date()).toISOString(),
-    pages: allPages.map((p) => ({ path: p.path, isStatic: p.isStatic })),
-    assets: { js: jsEntry, css: cssEntries }
-  };
-  fs5.writeFileSync(
-    path5.join(distDir, "build-manifest.json"),
-    JSON.stringify(buildManifest, null, 2),
-    "utf-8"
-  );
-  const duration = Date.now() - startTime;
-  const successCount = staticPages.length - failedPages.length;
-  console.log(`
-\u2728 SSG Complete!`);
-  console.log(`   ${successCount}/${staticPages.length} pages generated`);
-  console.log(`   Duration: ${duration}ms
-`);
-  return {
-    totalPages: allPages.length,
-    staticPages: successCount,
-    failedPages,
-    duration
-  };
-}
-function createSSGConfig(root, options = {}) {
-  return {
-    root,
-    appDir: options.appDir || "src/app",
-    outDir: options.outDir || "dist",
-    extensions: options.extensions || [".tsx", ".ts", ".jsx", ".js"],
-    basePath: options.basePath || ""
-  };
-}
-var init_prerender = __esm({
-  "src/ssg/prerender.ts"() {
-    "use strict";
-    init_crawler();
-    init_generator();
-    init_renderer();
-    init_html();
-  }
-});
-
-// src/ssg/index.ts
-var ssg_exports = {};
-__export(ssg_exports, {
-  cleanupSSREntry: () => cleanupSSREntry,
-  crawlRoutes: () => crawlRoutes,
-  createSSGConfig: () => createSSGConfig,
-  discoverBuildAssets: () => discoverBuildAssets,
-  generateHTML: () => generateHTML,
-  generateHydrationScript: () => generateHydrationScript,
-  generateMetaTags: () => generateMetaTags,
-  generateRobotsTxt: () => generateRobotsTxt,
-  generateSSREntry: () => generateSSREntry,
-  generateSitemap: () => generateSitemap,
-  getDynamicPages: () => getDynamicPages,
-  getStaticPages: () => getStaticPages,
-  injectContentIntoHTML: () => injectContentIntoHTML,
-  renderPage: () => renderPage,
-  renderPages: () => renderPages,
-  runSSG: () => runSSG
-});
-var init_ssg = __esm({
-  "src/ssg/index.ts"() {
-    "use strict";
-    init_prerender();
-    init_crawler();
-    init_generator();
-    init_renderer();
-    init_html();
-  }
-});
-
-// src/plugin.ts
-var VIRTUAL_MODULE_ID = "virtual:olova-routes";
-var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-var VIRTUAL_METADATA_ID = "virtual:olova-metadata";
-var RESOLVED_VIRTUAL_METADATA_ID = "\0" + VIRTUAL_METADATA_ID;
-function olova(options = {}) {
-  const {
-    appDir = "src/app",
-    extensions = [".tsx", ".ts", ".jsx", ".js"],
-    basePath = "",
-    trailingSlash = false,
-    ssg = false
-  } = options;
-  let root;
-  let routeManifest = null;
-  let routeMetadataMap = /* @__PURE__ */ new Map();
-  let rootMetadata = null;
-  return {
-    name: "vite-plugin-olova",
-    enforce: "pre",
-    configResolved(config) {
-      root = config.root;
-    },
-    resolveId(id) {
-      if (id === VIRTUAL_MODULE_ID) {
-        return RESOLVED_VIRTUAL_MODULE_ID;
-      }
-      if (id === VIRTUAL_METADATA_ID) {
-        return RESOLVED_VIRTUAL_METADATA_ID;
-      }
-    },
-    async load(id) {
-      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        const manifest = await generateRouteManifest(root, appDir, extensions);
-        return generateRouteCode(manifest, appDir);
-      }
-      if (id === RESOLVED_VIRTUAL_METADATA_ID) {
-        const metadataEntries = Array.from(routeMetadataMap.entries());
-        return generateMetadataCode(metadataEntries, rootMetadata);
-      }
-    },
-    // Configure Vite for SPA mode
-    config() {
-      return {
-        appType: "spa"
-      };
-    },
-    configureServer(server) {
-      server.watcher.add(`${root}/${appDir}/**/*`);
-      server.watcher.on("add", (file) => {
-        if (isRouteFile(file, extensions)) {
-          const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
-          if (mod) {
-            server.moduleGraph.invalidateModule(mod);
-            server.ws.send({ type: "full-reload" });
-          }
-        }
-      });
-      server.watcher.on("unlink", (file) => {
-        if (isRouteFile(file, extensions)) {
-          const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
-          if (mod) {
-            server.moduleGraph.invalidateModule(mod);
-            server.ws.send({ type: "full-reload" });
-          }
-        }
-      });
-      server.watcher.on("change", (file) => {
-        if (isRouteFile(file, extensions)) {
-          const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
-          if (mod) {
-            server.moduleGraph.invalidateModule(mod);
-          }
-          const metaMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_METADATA_ID);
-          if (metaMod) {
-            server.moduleGraph.invalidateModule(metaMod);
-          }
-        }
-      });
-      server.middlewares.use((req, res, next) => {
-        const url = req.url || "";
-        const accept = req.headers.accept || "";
-        if (!accept.includes("text/html")) {
-          return next();
-        }
-        if (url === "/" || url === "/index.html" || /\.[a-zA-Z0-9]+$/.test(url) || url.startsWith("/@") || url.startsWith("/node_modules") || url.startsWith("/__vite") || url.startsWith("/src") || url.startsWith("/api")) {
-          return next();
-        }
-        req.url = "/index.html";
-        next();
-      });
-    },
-    async buildStart() {
-      routeManifest = await generateRouteManifest(root, appDir, extensions);
-      const routes = await scanRoutesWithMetadata(root, appDir, extensions);
-      routeMetadataMap.clear();
-      for (const route of routes) {
-        routeMetadataMap.set(route.path, {
-          routePath: route.path,
-          metadata: route.metadata,
-          hasGenerateMetadata: route.hasGenerateMetadata
-        });
-        if (route.path === "/") {
-          rootMetadata = route.metadata;
-        }
-      }
-    },
-    // SSG: Generate separate HTML files for each route with pre-rendered content
-    async closeBundle() {
-      if (!ssg) return;
-      const { runSSG: runSSG2, createSSGConfig: createSSGConfig2 } = await Promise.resolve().then(() => (init_ssg(), ssg_exports));
-      const ssgConfig = createSSGConfig2(root, {
-        appDir,
-        outDir: "dist",
-        extensions
-      });
-      try {
-        await runSSG2(ssgConfig);
-      } catch (error) {
-        console.error("[olova] SSG failed:", error.message);
-      }
-    }
-  };
-}
-function isRouteFile(file, extensions) {
-  const routeFiles = ["page", "layout", "loading", "error", "not-found"];
-  return extensions.some(
-    (ext) => routeFiles.some((name) => file.endsWith(`${name}${ext}`))
-  );
-}
-async function scanRoutesWithMetadata(root, appDir, extensions) {
-  const fs6 = await import("fs");
-  const path6 = await import("path");
-  const routes = [];
-  const appPath = path6.join(root, appDir);
-  if (!fs6.existsSync(appPath)) {
-    return routes;
-  }
-  async function scanDir(dir, routePath) {
-    const entries = fs6.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        let segment = entry.name;
-        if (segment.startsWith("(") && segment.endsWith(")")) {
-          await scanDir(fullPath, routePath);
-          continue;
-        }
-        if (segment.startsWith("[") && segment.endsWith("]")) {
-          if (segment.startsWith("[...")) {
-            segment = ":" + segment.slice(4, -1) + "*";
-          } else if (segment.startsWith("[[...")) {
-            segment = ":" + segment.slice(5, -2) + "*";
-          } else {
-            segment = ":" + segment.slice(1, -1);
-          }
-        }
-        const newRoutePath = routePath === "/" ? `/${segment}` : `${routePath}/${segment}`;
-        await scanDir(fullPath, newRoutePath);
-      } else if (entry.isFile()) {
-        const isPage = extensions.some((ext) => entry.name === `page${ext}`);
-        if (isPage) {
-          const metadata = await extractMetadataFromFile(fullPath);
-          const hasGenerateMetadata = await checkForGenerateMetadata(fullPath);
-          routes.push({
-            path: routePath || "/",
-            filePath: fullPath,
-            metadata,
-            hasGenerateMetadata
-          });
-        }
-      }
-    }
-  }
-  await scanDir(appPath, "/");
-  return routes;
-}
-async function extractMetadataFromFile(filePath) {
-  const fs6 = await import("fs");
-  try {
-    const content = fs6.readFileSync(filePath, "utf-8");
-    const metadataMatch = content.match(/export\s+const\s+metadata\s*=\s*(\{[\s\S]*?\n\};?)/);
-    if (metadataMatch) {
-      try {
-        const metadataStr = metadataMatch[1];
-        const jsonLike = metadataStr.replace(/'/g, '"').replace(/,(\s*[}\]])/g, "$1").replace(/(\w+):/g, '"$1":').replace(/""(\w+)"":/g, '"$1":');
-        const metadata = Function('"use strict"; return (' + metadataStr + ")")();
-        return metadata;
-      } catch (e) {
-        return extractMetadataSimple2(content);
-      }
-    }
-    return null;
-  } catch (e) {
-    console.warn(`[olova] Failed to extract metadata from ${filePath}:`, e);
-    return null;
-  }
-}
-function extractMetadataSimple2(content) {
-  const metadata = {};
-  const titleMatch = content.match(/title:\s*['"`]([^'"`]+)['"`]/);
-  if (titleMatch) metadata.title = titleMatch[1];
-  const descMatch = content.match(/description:\s*['"`]([^'"`]+)['"`]/);
-  if (descMatch) metadata.description = descMatch[1];
-  const keywordsMatch = content.match(/keywords:\s*\[([^\]]+)\]/);
-  if (keywordsMatch) {
-    const keywords = keywordsMatch[1].split(",").map((k) => k.trim().replace(/['"`]/g, "")).filter(Boolean);
-    if (keywords.length) metadata.keywords = keywords;
-  }
-  return Object.keys(metadata).length > 0 ? metadata : null;
-}
-async function checkForGenerateMetadata(filePath) {
-  const fs6 = await import("fs");
-  try {
-    const content = fs6.readFileSync(filePath, "utf-8");
-    return /export\s+(async\s+)?function\s+generateMetadata/.test(content);
-  } catch (e) {
-    return false;
-  }
-}
-async function generateRouteManifest(root, appDir, extensions) {
-  return {
-    routes: [],
-    staticPaths: /* @__PURE__ */ new Map(),
-    generatedAt: Date.now()
-  };
-}
-function generateRouteCode(manifest, appDir) {
-  return `
-import { lazy } from 'react';
-
-// Auto-generated by olova
-// This file is generated at build time based on your file structure
-
-export const routes = [];
-export const manifest = ${JSON.stringify({ generatedAt: manifest.generatedAt })};
-`;
-}
-function generateMetadataCode(entries, rootMetadata) {
-  const metadataMap = {};
-  for (const [path6, routeMeta] of entries) {
-    metadataMap[path6] = routeMeta.metadata;
-  }
-  return `
-// Auto-generated by olova - Route Metadata
-export const routeMetadata = ${JSON.stringify(metadataMap, null, 2)};
-export const rootMetadata = ${JSON.stringify(rootMetadata, null, 2)};
-
-export function getMetadataForRoute(path) {
-  return routeMetadata[path] || rootMetadata || null;
-}
-`;
-}
-var plugin_default = olova;
-export {
-  plugin_default as default,
-  olova
-};
-//# sourceMappingURL=plugin.js.map