olova 2.0.55 → 2.0.56

package/dist/ssg.cjs

@@ -1,637 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// 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
-});
-module.exports = __toCommonJS(ssg_exports);
-
-// src/ssg/prerender.ts
-var import_fs5 = __toESM(require("fs"), 1);
-var import_path5 = __toESM(require("path"), 1);
-
-// src/ssg/crawler.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-async function crawlRoutes(config) {
-  const appPath = import_path.default.resolve(config.root, config.appDir);
-  if (!import_fs.default.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 = import_fs.default.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = import_path.default.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 = import_fs.default.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);
-}
-
-// src/ssg/generator.ts
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-function generateSSREntry(pages, config) {
-  const entryPath = import_path2.default.resolve(config.root, ".olova-ssg-entry.tsx");
-  const imports = [];
-  const routeMap = [];
-  const appDir = import_path2.default.resolve(config.root, config.appDir);
-  const layoutPath = findLayoutFile(appDir, config.extensions);
-  if (layoutPath) {
-    const relativePath = import_path2.default.relative(config.root, layoutPath).replace(/\\/g, "/");
-    imports.push(`import Layout from './${relativePath}';`);
-  }
-  pages.forEach((page, index) => {
-    const relativePath = import_path2.default.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)};
-`;
-  import_fs2.default.writeFileSync(entryPath, entryContent, "utf-8");
-  return entryPath;
-}
-function findLayoutFile(dir, extensions) {
-  for (const ext of extensions) {
-    const layoutPath = import_path2.default.join(dir, `layout${ext}`);
-    if (import_fs2.default.existsSync(layoutPath)) {
-      return layoutPath;
-    }
-  }
-  return null;
-}
-function cleanupSSREntry(entryPath) {
-  try {
-    if (import_fs2.default.existsSync(entryPath)) {
-      import_fs2.default.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>
-`;
-}
-
-// src/ssg/renderer.ts
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path3 = __toESM(require("path"), 1);
-var import_url = require("url");
-var import_vite = require("vite");
-async function renderPage(page, config, ssrEntryPath) {
-  const tempSSRDir = import_path3.default.join(config.root, ".olova", "ssr");
-  if (!import_fs3.default.existsSync(tempSSRDir)) {
-    import_fs3.default.mkdirSync(tempSSRDir, { recursive: true });
-  }
-  const pkgPath = import_path3.default.join(tempSSRDir, "package.json");
-  if (!import_fs3.default.existsSync(pkgPath)) {
-    import_fs3.default.writeFileSync(pkgPath, JSON.stringify({ type: "module" }));
-  }
-  const outputFileName = `ssr-entry-${Date.now()}.js`;
-  const outputPath = import_path3.default.join(tempSSRDir, outputFileName);
-  try {
-    await (0, import_vite.build)({
-      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 (import_fs3.default.existsSync(outputPath)) {
-      const moduleUrl = (0, import_url.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 (import_fs3.default.existsSync(outputPath)) {
-      try {
-        import_fs3.default.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;
-}
-
-// src/ssg/html.ts
-var import_fs4 = __toESM(require("fs"), 1);
-var import_path4 = __toESM(require("path"), 1);
-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 = import_path4.default.join(distDir, "assets");
-  if (import_fs4.default.existsSync(assetsDir)) {
-    const assets = import_fs4.default.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`;
-}
-
-// src/ssg/prerender.ts
-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 = import_path5.default.resolve(config.root, config.outDir);
-  const { jsEntry, cssEntries } = discoverBuildAssets(distDir);
-  console.log(`   JS entry: ${jsEntry || "(none)"}`);
-  console.log(`   CSS files: ${cssEntries.length}
-`);
-  const baseHtmlPath = import_path5.default.join(distDir, "index.html");
-  let baseHtml = "";
-  if (import_fs5.default.existsSync(baseHtmlPath)) {
-    baseHtml = import_fs5.default.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 === "/" ? import_path5.default.join(distDir, "index.html") : import_path5.default.join(distDir, page.path, "index.html");
-      const outputDir = import_path5.default.dirname(outputPath);
-      if (!import_fs5.default.existsSync(outputDir)) {
-        import_fs5.default.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>`
-        );
-      }
-      import_fs5.default.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);
-  import_fs5.default.writeFileSync(import_path5.default.join(distDir, "sitemap.xml"), sitemap, "utf-8");
-  console.log("   \u2705 sitemap.xml");
-  const robotsPath = import_path5.default.join(distDir, "robots.txt");
-  if (!import_fs5.default.existsSync(robotsPath)) {
-    import_fs5.default.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 }
-  };
-  import_fs5.default.writeFileSync(
-    import_path5.default.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 || ""
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cleanupSSREntry,
-  crawlRoutes,
-  createSSGConfig,
-  discoverBuildAssets,
-  generateHTML,
-  generateHydrationScript,
-  generateMetaTags,
-  generateRobotsTxt,
-  generateSSREntry,
-  generateSitemap,
-  getDynamicPages,
-  getStaticPages,
-  injectContentIntoHTML,
-  renderPage,
-  renderPages,
-  runSSG
-});
-//# sourceMappingURL=ssg.cjs.map