vite-react-ssg 0.6.1 → 0.6.3

package/dist/node.mjs

@@ -1,18 +1,15 @@
 import { join, isAbsolute, parse, dirname } from 'node:path';
 import { createRequire } from 'node:module';
-import { gray, yellow, blue, dim, cyan, red, green, bold, reset, bgLightCyan } from 'kolorist';
+import { gray, yellow, blue, dim, cyan, red, green, reset, bold, bgLightCyan } from 'kolorist';
 import fs from 'fs-extra';
-import { resolveConfig, build as build$1, mergeConfig, version as version$1, createServer } from 'vite';
+import { resolveConfig, build as build$1, mergeConfig, version as version$1, createServer, send } from 'vite';
 import { JSDOM } from 'jsdom';
-import { s as serializeState } from './shared/vite-react-ssg.a009fbf1.mjs';
+import { s as serializeState } from './shared/vite-react-ssg.579feabb.mjs';
 import { readFileSync } from 'node:fs';
 import React from 'react';
 import { HelmetProvider } from 'react-helmet-async';
 import { Writable } from 'node:stream';
 import { renderToPipeableStream } from 'react-dom/server';
-import https from 'node:https';
-import express from 'express';
-import { certificateFor } from '@childrentime/devcert';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -857,10 +854,18 @@ async function routesToPaths(routes) {
   if (!routes || routes.length === 0)
     return { paths: ["/"], pathToEntry };
   const paths = /* @__PURE__ */ new Set();
-  const lazyPaths = /* @__PURE__ */ new Set();
   const getPaths = async (routes2, prefix = "") => {
     prefix = prefix.replace(/\/$/g, "");
-    for (const route of routes2) {
+    for (let route of routes2) {
+      if (route.lazy) {
+        const lazyData = await route.lazy();
+        if (lazyData) {
+          route = {
+            ...route,
+            ...lazyData
+          };
+        }
+      }
       let path = route.path;
       path = handlePath(path, prefix, route.entry);
       if (route.getStaticPaths && isDynamicSegmentsRoute(path)) {
@@ -871,8 +876,6 @@ async function routesToPaths(routes) {
             await getPaths(route.children, staticPath);
         }
       }
-      if (route.lazy)
-        lazyPaths.add(route.index ? prefix : path ?? "");
       if (route.index)
         addEntry(prefix, route.entry);
       if (Array.isArray(route.children))
@@ -880,7 +883,7 @@ async function routesToPaths(routes) {
     }
   };
   await getPaths(routes);
-  return { paths: Array.from(paths), pathToEntry, lazyPaths: Array.from(lazyPaths) };
+  return { paths: Array.from(paths), pathToEntry };
   function handlePath(path, prefix, entry) {
     if (path != null) {
       path = prefix && !path.startsWith("/") ? `${prefix}${path ? `/${path}` : ""}` : path;
@@ -894,31 +897,6 @@ async function routesToPaths(routes) {
     return path;
   }
 }
-function createFetchRequest(req) {
-  const origin = `${req.protocol}://${req.get("host")}`;
-  const url = new URL(req.originalUrl || req.url, origin);
-  const controller = new AbortController();
-  req.on("close", () => controller.abort());
-  const headers = new Headers();
-  for (const [key, values] of Object.entries(req.headers)) {
-    if (values) {
-      if (Array.isArray(values)) {
-        for (const value of values)
-          headers.append(key, value);
-      } else {
-        headers.set(key, values);
-      }
-    }
-  }
-  const init = {
-    method: req.method,
-    headers,
-    signal: controller.signal
-  };
-  if (req.method !== "GET" && req.method !== "HEAD")
-    init.body = req.body;
-  return new Request(url.href, init);
-}
 async function resolveAlias(config, entry) {
   const resolver = config.createResolver();
   const result = await resolver(entry, config.root);
@@ -951,10 +929,6 @@ function withTrailingSlash(path) {
     return `${path}/`;
   return path;
 }
-const postfixRE = /[?#].*$/s;
-function cleanUrl(url) {
-  return url.replace(postfixRE, "");
-}
 const dynamicRE = /[:*?]/;
 function isDynamicSegmentsRoute(route) {
   if (!route)
@@ -1054,17 +1028,6 @@ async function render(routesOrApp, request, styleCollector, basename) {
   const { htmlAttributes, bodyAttributes, metaAttributes, styleTag } = extractHelmet(helmetContext, styleCollector);
   return { appHTML, htmlAttributes, bodyAttributes, metaAttributes, styleTag, routerContext: context };
 }
-async function preLoad(routes, paths) {
-  if (!paths || paths.length === 0)
-    return routes;
-  const { createStaticHandler } = await import('react-router-dom/server.js');
-  const { dataRoutes, query } = createStaticHandler(routes);
-  await Promise.all(paths.map(async (path) => {
-    const request = createRequest(path);
-    return query(request);
-  }));
-  return dataRoutes;
-}
 function extractHelmet(context, styleCollector) {
   const { helmet } = context;
   const htmlAttributes = helmet.htmlAttributes.toString();
@@ -1080,56 +1043,6 @@ function extractHelmet(context, styleCollector) {
   return { htmlAttributes, bodyAttributes, metaAttributes, styleTag };
 }
 
-function renderPreloadLinks(document, modules, ssrManifest) {
-  const seen = /* @__PURE__ */ new Set();
-  const preloadLinks = [];
-  Array.from(modules).forEach((id) => {
-    const files = ssrManifest[id] || [];
-    files.forEach((file) => {
-      if (!preloadLinks.includes(file))
-        preloadLinks.push(file);
-    });
-  });
-  if (preloadLinks) {
-    preloadLinks.forEach((file) => {
-      if (!seen.has(file)) {
-        seen.add(file);
-        renderPreloadLink(document, file);
-      }
-    });
-  }
-}
-function renderPreloadLink(document, file) {
-  if (file.endsWith(".js")) {
-    appendLink(document, {
-      rel: "modulepreload",
-      crossOrigin: "",
-      href: file
-    });
-  } else if (file.endsWith(".css")) {
-    appendLink(document, {
-      rel: "stylesheet",
-      href: file
-    });
-  }
-}
-function createLink$1(document) {
-  return document.createElement("link");
-}
-function setAttrs(el, attrs) {
-  const keys = Object.keys(attrs);
-  for (const key of keys)
-    el.setAttribute(key, attrs[key]);
-}
-function appendLink(document, attrs) {
-  const exits = document.head.querySelector(`link[href='${attrs.file}']`);
-  if (exits)
-    return;
-  const link = createLink$1(document);
-  setAttrs(link, attrs);
-  document.head.appendChild(link);
-}
-
 async function renderHTML({
   rootContainerId,
   indexHTML,
@@ -1173,7 +1086,7 @@ async function renderHTML({
   return renderedOutput;
 }
 async function detectEntry(root) {
-  const scriptSrcReg = /<script(?:.*?)src=["'](.+?)["'](?!<)(?:.*)\>(?:[\n\r\s]*?)(?:<\/script>)/img;
+  const scriptSrcReg = /<script(?:.*?)src=["'](.+?)["'](?!<)(?:.*)\>(?:[\n\r\s]*?)(?:<\/script>)/gim;
   const html = await fs.readFile(join(root, "index.html"), "utf-8");
   const scripts = [...html.matchAll(scriptSrcReg)];
   const [, entry] = scripts.find((matchResult) => {
@@ -1183,10 +1096,61 @@ async function detectEntry(root) {
   }) || [];
   return entry || "src/main.ts";
 }
-function createLink(href) {
+function createLink$1(href) {
   return `<link rel="stylesheet" href="${href}">`;
 }
 
+function renderPreloadLinks(document, modules, ssrManifest) {
+  const seen = /* @__PURE__ */ new Set();
+  const preloadLinks = [];
+  Array.from(modules).forEach((id) => {
+    const files = ssrManifest[id] || [];
+    files.forEach((file) => {
+      if (!preloadLinks.includes(file))
+        preloadLinks.push(file);
+    });
+  });
+  if (preloadLinks) {
+    preloadLinks.forEach((file) => {
+      if (!seen.has(file)) {
+        seen.add(file);
+        renderPreloadLink(document, file);
+      }
+    });
+  }
+}
+function renderPreloadLink(document, file) {
+  if (file.endsWith(".js")) {
+    appendLink(document, {
+      rel: "modulepreload",
+      crossOrigin: "",
+      href: file
+    });
+  } else if (file.endsWith(".css")) {
+    appendLink(document, {
+      rel: "stylesheet",
+      href: file,
+      crossOrigin: ""
+    });
+  }
+}
+function createLink(document) {
+  return document.createElement("link");
+}
+function setAttrs(el, attrs) {
+  const keys = Object.keys(attrs);
+  for (const key of keys)
+    el.setAttribute(key, attrs[key]);
+}
+function appendLink(document, attrs) {
+  const exits = document.head.querySelector(`link[href='${attrs.file}']`);
+  if (exits)
+    return;
+  const link = createLink(document);
+  setAttrs(link, attrs);
+  document.head.appendChild(link);
+}
+
 function DefaultIncludedRoutes(paths, _routes) {
   return paths.filter((i) => !i.includes(":") && !i.includes("*"));
 }
@@ -1268,9 +1232,7 @@ async function build(ssgOptions = {}, viteConfig = {}) {
   const { createRoot, includedRoutes: serverEntryIncludedRoutes } = format === "esm" ? await import(serverEntry) : _require(serverEntry);
   const includedRoutes = serverEntryIncludedRoutes || configIncludedRoutes;
   const { routes } = await createRoot(false);
-  const { lazyPaths } = await routesToPaths(routes);
-  const dataRoutes = await preLoad([...routes || []], lazyPaths);
-  const { paths, pathToEntry } = await routesToPaths(dataRoutes);
+  const { paths, pathToEntry } = await routesToPaths(routes);
   let routesPaths = includeAllRoutes ? paths : await includedRoutes(paths, routes || []);
   routesPaths = DefaultIncludedRoutes(routesPaths);
   routesPaths = Array.from(new Set(routesPaths));
@@ -1310,8 +1272,10 @@ async function build(ssgOptions = {}, viteConfig = {}) {
         renderPreloadLinks(jsdom.window.document, modules, ssrManifest);
         const html = jsdom.serialize();
         let transformed = await onPageRendered?.(path, html, appCtx) || html;
-        if (critters)
+        if (critters) {
           transformed = await crittersQueue.add(() => critters.process(transformed));
+          transformed = transformed.replace(/<link\srel="stylesheet"/g, '<link rel="stylesheet" crossorigin');
+        }
         if (styleTag)
           transformed = transformed.replace("<head>", `<head>${styleTag}`);
         const formatted = await formatHtml(transformed, formatting);
@@ -1361,9 +1325,14 @@ async function formatHtml(html, formatting) {
       minifyCSS: true
     });
   } else if (formatting === "prettify") {
-    const prettier = (await import('prettier/esm/standalone.mjs')).default;
-    const parserHTML = (await import('prettier/esm/parser-html.mjs')).default;
-    return prettier.format(html, { semi: false, parser: "html", plugins: [parserHTML] });
+    try {
+      const prettier = (await import('prettier/esm/standalone.mjs')).default;
+      const parserHTML = (await import('prettier/esm/parser-html.mjs')).default;
+      return prettier.format(html, { semi: false, parser: "html", plugins: [parserHTML] });
+    } catch (e) {
+      console.error(`${gray("[vite-react-ssg]")} ${red(`Error formatting html: ${e?.message}`)}`);
+      return html;
+    }
   }
   return html;
 }
@@ -1385,114 +1354,48 @@ function collectModules(manifest, entry, mods = /* @__PURE__ */ new Set()) {
   return mods;
 }
 
-const SHORTCUTS = [
-  {
-    key: "u",
-    description: "show server url",
-    action(vite, _) {
-      vite.config.logger.info("");
-      printServerInfo(vite, true);
-    }
-  },
-  {
-    key: "c",
-    description: "clear console",
-    action(vite, _) {
-      vite.config.logger.clearScreen("error");
-    }
-  },
-  {
-    key: "q",
-    description: "quit",
-    action(_, server) {
-      server.close(() => process.exit());
-    }
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    console.error(
+      "The following error is a bug in Remix; please open an issue! https://github.com/remix-run/remix/issues/new"
+    );
+    throw new Error(message);
   }
-];
-function bindShortcuts(viteServer, server) {
-  if (!process.stdin.isTTY || process.env.CI)
-    return;
-  viteServer.config.logger.info(
-    dim(green("  \u279C")) + dim("  press ") + bold("h") + dim(" to show help")
-  );
-  const shortcuts = SHORTCUTS;
-  let actionRunning = false;
-  const onInput = async (input) => {
-    if (input === "" || input === "") {
-      try {
-        await server.close();
-      } finally {
-        process.exit(1);
-      }
-      return;
-    }
-    if (actionRunning)
-      return;
-    if (input === "h") {
-      viteServer.config.logger.info(
-        [
-          "",
-          bold("  Shortcuts"),
-          ...shortcuts.map(
-            (shortcut2) => dim("  press ") + bold(shortcut2.key) + dim(` to ${shortcut2.description}`)
-          )
-        ].join("\n")
-      );
-    }
-    const shortcut = shortcuts.find((shortcut2) => shortcut2.key === input);
-    if (!shortcut)
-      return;
-    actionRunning = true;
-    await shortcut.action(viteServer, server);
-    actionRunning = false;
-  };
-  process.stdin.setRawMode(true);
-  process.stdin.on("data", onInput).setEncoding("utf8").resume();
-  server.on("close", () => {
-    process.stdin.off("data", onInput).pause();
-  });
 }
 
-function baseMiddleware(rawBase) {
-  return (req, res, next) => {
-    const url = req.url;
-    const pathname = cleanUrl(url);
-    const base = rawBase;
-    if (pathname.startsWith(base))
-      return next();
-    if (pathname === "/" || pathname === "/index.html") {
-      res.writeHead(302, {
-        Location: base + url.slice(pathname.length)
-      });
-      res.end();
-      return;
-    }
-    const redirectPath = withTrailingSlash(url) !== base ? joinUrlSegments(base, url) : base;
-    if (req.headers.accept?.includes("text/html")) {
-      res.writeHead(404, {
-        "Content-Type": "text/html"
-      });
-      res.end(
-        `The server is configured with a public base URL of ${base} - did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`
-      );
-    } else {
-      res.writeHead(404, {
-        "Content-Type": "text/plain"
-      });
-      res.end(
-        `The server is configured with a public base URL of ${base} - did you mean to visit ${redirectPath} instead?`
-      );
+function fromNodeHeaders(nodeHeaders) {
+  const headers = new Headers();
+  for (const [key, values] of Object.entries(nodeHeaders)) {
+    if (values) {
+      if (Array.isArray(values)) {
+        for (const value of values)
+          headers.append(key, value);
+      } else {
+        headers.set(key, values);
+      }
     }
+  }
+  return headers;
+}
+function fromNodeRequest(nodeReq) {
+  const origin = nodeReq.headers.origin && nodeReq.headers.origin !== "null" ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+  invariant(
+    nodeReq.originalUrl,
+    "Expected `nodeReq.originalUrl` to be defined"
+  );
+  const url = new URL(nodeReq.originalUrl, origin);
+  const init = {
+    method: nodeReq.method,
+    headers: fromNodeHeaders(nodeReq.headers)
   };
+  return new Request(url.href, init);
 }
 
-async function dev(ssgOptions = {}, viteConfig = {}) {
+async function dev(ssgOptions = {}, viteConfig = {}, customOptions) {
   const mode = process.env.MODE || process.env.NODE_ENV || ssgOptions.mode || "development";
   const config = await resolveConfig(viteConfig, "serve", mode, mode);
   const cwd = process.cwd();
   const root = config.root || cwd;
-  const httpsOptions = config.server.https;
-  setBase(config.rawBase);
   const {
     entry = await detectEntry(root),
     onBeforePageRender,
@@ -1504,21 +1407,12 @@ async function dev(ssgOptions = {}, viteConfig = {}) {
   const template = await fs.readFile(join(root, "index.html"), "utf-8");
   let viteServer;
   globalThis.__ssr_start_time = performance.now();
-  createServer$1().then(async (app) => {
-    const port = viteServer.config.server.port || 5173;
-    if (httpsOptions) {
-      const localHttpsOptions = typeof httpsOptions === "boolean" ? await certificateFor(["localhost"]) : httpsOptions;
-      const server = https.createServer(localHttpsOptions, app);
-      server.listen(port, () => {
-        printServerInfo(viteServer, false, true);
-        bindShortcuts(viteServer, server);
-      });
-    } else {
-      const server = app.listen(port, () => {
-        printServerInfo(viteServer);
-        bindShortcuts(viteServer, server);
-      });
-    }
+  createServer$1().catch((err) => {
+    console.error(
+      `${red(`failed to start server. error:`)}
+${err.stack}`
+    );
+    process.exit(1);
   });
   async function createServer$1() {
     process.env.__DEV_MODE_SSR = "true";
@@ -1526,108 +1420,105 @@ async function dev(ssgOptions = {}, viteConfig = {}) {
       const { jsdomGlobal } = await import('./chunks/jsdomGlobal.mjs');
       jsdomGlobal();
     }
-    const app = express();
     viteServer = await createServer({
-      // ...options,
-      server: { middlewareMode: true },
-      appType: "custom"
-    });
-    app.use(baseMiddleware(getBase()));
-    app.use((req, res, next) => {
-      viteServer.middlewares.handle(req, res, next);
-    });
-    app.use("*", async (req, res) => {
-      try {
-        const url = req.originalUrl;
-        const indexHTML = await viteServer.transformIndexHtml(url, template);
-        const createRoot = await viteServer.ssrLoadModule(ssrEntry).then((m) => m.createRoot);
-        const appCtx = await createRoot(false, url);
-        const { routes, getStyleCollector, base: base2, app: app2 } = appCtx;
-        const transformedIndexHTML = await onBeforePageRender?.(url, indexHTML, appCtx) || indexHTML;
-        const styleCollector = getStyleCollector ? await getStyleCollector() : null;
-        const { appHTML, bodyAttributes, htmlAttributes, metaAttributes, styleTag, routerContext } = await render(app2 ?? [...routes], createFetchRequest(req), styleCollector, base2);
-        metaAttributes.push(styleTag);
-        const matchesEntries = routerContext?.matches.map((match) => match.route.entry).filter((entry2) => !!entry2).map((entry2) => entry2[0] === "/" ? entry2 : `/${entry2}`) ?? [];
-        const mods = await Promise.all(
-          [entry, ...matchesEntries].map(async (entry2) => await viteServer.moduleGraph.getModuleByUrl(entry2))
-        );
-        const assetsUrls = /* @__PURE__ */ new Set();
-        const collectAssets = async (mod) => {
-          if (!mod || !mod?.ssrTransformResult)
-            return;
-          const { deps = [], dynamicDeps = [] } = mod?.ssrTransformResult;
-          const allDeps = [...deps, ...dynamicDeps];
-          for (const dep of allDeps) {
-            if (dep.endsWith(".css")) {
-              assetsUrls.add(dep);
-            } else if (dep.endsWith(".ts") || dep.endsWith(".tsx")) {
-              const depModule = await viteServer.moduleGraph.getModuleByUrl(dep);
-              depModule && await collectAssets(depModule);
-            }
+      ...viteConfig,
+      plugins: [
+        ...viteConfig.plugins ?? [],
+        {
+          name: "vite-react-ssg:dev-server-remix",
+          configureServer(server) {
+            return () => {
+              server.middlewares.use(async (req, res, _next) => {
+                try {
+                  const url = req.originalUrl;
+                  const indexHTML = await viteServer.transformIndexHtml(url, template);
+                  const createRoot = await viteServer.ssrLoadModule(ssrEntry).then((m) => m.createRoot);
+                  const appCtx = await createRoot(false, url);
+                  const { routes, getStyleCollector, base, app } = appCtx;
+                  const transformedIndexHTML = await onBeforePageRender?.(url, indexHTML, appCtx) || indexHTML;
+                  const styleCollector = getStyleCollector ? await getStyleCollector() : null;
+                  const { appHTML, bodyAttributes, htmlAttributes, metaAttributes, styleTag, routerContext } = await render(app ?? [...routes], fromNodeRequest(req), styleCollector, base);
+                  metaAttributes.push(styleTag);
+                  const matchesEntries = routerContext?.matches.map((match) => match.route.entry).filter((entry2) => !!entry2).map((entry2) => entry2[0] === "/" ? entry2 : `/${entry2}`) ?? [];
+                  const mods = await Promise.all(
+                    [ssrEntry, entry, ...matchesEntries].map(async (entry2) => await viteServer.moduleGraph.getModuleByUrl(entry2))
+                  );
+                  const assetsUrls = /* @__PURE__ */ new Set();
+                  const collectAssets = async (mod) => {
+                    if (!mod || !mod?.ssrTransformResult)
+                      return;
+                    const { deps = [], dynamicDeps = [] } = mod?.ssrTransformResult;
+                    const allDeps = [...deps, ...dynamicDeps];
+                    for (const dep of allDeps) {
+                      if (dep.endsWith(".css")) {
+                        assetsUrls.add(dep);
+                      } else if (dep.endsWith(".ts") || dep.endsWith(".tsx")) {
+                        const depModule = await viteServer.moduleGraph.getModuleByUrl(dep);
+                        depModule && await collectAssets(depModule);
+                      }
+                    }
+                  };
+                  await Promise.all(mods.map(async (mod) => collectAssets(mod)));
+                  const preloadLink = [...assetsUrls].map((item) => createLink$1(joinUrlSegments(config.base, item)));
+                  metaAttributes.push(...preloadLink);
+                  const renderedHTML = await renderHTML({
+                    rootContainerId,
+                    appHTML,
+                    indexHTML: transformedIndexHTML,
+                    metaAttributes,
+                    bodyAttributes,
+                    htmlAttributes,
+                    initialState: null
+                  });
+                  const transformed = await onPageRendered?.(url, renderedHTML, appCtx) || renderedHTML;
+                  res.statusCode = 200;
+                  res.setHeader("Content-Type", "text/html");
+                  const isDev = "pluginContainer" in server;
+                  const headers = isDev ? server.config.server.headers : server.config.preview.headers;
+                  send(req, res, transformed, "html", { headers });
+                } catch (e) {
+                  viteServer.ssrFixStacktrace(e);
+                  console.error(`[vite-react-ssg] error: ${e.stack}`);
+                  res.statusCode = 500;
+                  res.end(e.stack);
+                }
+              });
+            };
           }
-        };
-        await Promise.all(mods.map(async (mod) => collectAssets(mod)));
-        const preloadLink = [...assetsUrls].map((item) => createLink(item));
-        metaAttributes.push(...preloadLink);
-        const renderedHTML = await renderHTML({
-          rootContainerId,
-          appHTML,
-          indexHTML: transformedIndexHTML,
-          metaAttributes,
-          bodyAttributes,
-          htmlAttributes,
-          initialState: null
-        });
-        const transformed = await onPageRendered?.(url, renderedHTML, appCtx) || renderedHTML;
-        res.status(200).set({ "Content-Type": "text/html" }).end(transformed);
-      } catch (e) {
-        viteServer.ssrFixStacktrace(e);
-        console.error(`[vite-react-ssg] error: ${e.stack}`);
-        res.status(500).end(e.stack);
-      }
+        }
+      ]
     });
-    return app;
+    await viteServer.listen();
+    printServerInfo(viteServer, !!customOptions);
+    viteServer.bindCLIShortcuts({ print: true });
+    return viteServer;
   }
 }
-async function printServerInfo(server, onlyUrl = false, https2 = false) {
+async function printServerInfo(server, onlyUrl = false) {
+  if (onlyUrl)
+    return server.printUrls();
   const info = server.config.logger.info;
-  const port = server.config.server.port || 5173;
-  const protocol = https2 ? "https" : "http";
-  const url = `${protocol}://localhost:${port}/${removeLeadingSlash(getBase())}`;
-  if (!onlyUrl) {
-    let ssrReadyMessage = " -- SSR";
-    if (globalThis.__ssr_start_time) {
-      ssrReadyMessage += ` ready in ${reset(bold(`${Math.round(
-        // @ts-expect-error global var
-        performance.now() - globalThis.__ssr_start_time
-      )}ms`))}`;
-    }
-    info(
-      `
+  let ssrReadyMessage = " -- SSR";
+  if (globalThis.__ssr_start_time) {
+    ssrReadyMessage += ` ready in ${reset(bold(`${Math.round(
+      // @ts-expect-error global var
+      performance.now() - globalThis.__ssr_start_time
+    )}ms`))}`;
+  }
+  info(
+    `
  ${bgLightCyan(` VITE-REACT-SSG v${version} `)}`,
-      { clear: !server.config.logger.hasWarned }
-    );
-    info(
-      `${cyan(`
+    { clear: !server.config.logger.hasWarned }
+  );
+  info(
+    `${cyan(`
   VITE v${version$1}`) + dim(ssrReadyMessage)}
 `
-    );
-  }
+  );
   info(
     green("  dev server running at:")
   );
-  printUrls(url, info);
-}
-function printUrls(url, info) {
-  const colorUrl = (url2) => cyan(url2.replace(/:(\d+)\//, (_, port) => `:${bold(port)}/`));
-  info(`  ${green("\u279C")}  ${bold("Local")}:   ${colorUrl(url)}`);
-}
-let base = "";
-function getBase() {
-  return base;
-}
-function setBase(newBase) {
-  base = newBase;
+  server.printUrls();
 }
 
 export { build, dev };

package/dist/shared/{vite-react-ssg.a009fbf1.mjs → vite-react-ssg.579feabb.mjs}

@@ -1,4 +1,4 @@
-const UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g;
+const UNSAFE_CHARS_REGEXP = /[<>/\u2028\u2029]/g;
 const ESCAPED_CHARS = {
   "<": "\\u003C",
   ">": "\\u003E",

package/dist/shared/{vite-react-ssg.d734eb79.d.cts → vite-react-ssg.870c683b.d.cts}

@@ -110,9 +110,9 @@ interface ViteReactSSGContext<HasRouter extends boolean = true> {
     routerOptions: HasRouter extends true ? RouterOptions : undefined;
     initialState: Record<string, any>;
     isClient: boolean;
-    onSSRAppRendered(cb: Function): void;
-    triggerOnSSRAppRendered(route: string, appHTML: string, appCtx: ViteReactSSGContext): Promise<unknown[]>;
-    transformState?(state: any): any;
+    onSSRAppRendered: (cb: Function) => void;
+    triggerOnSSRAppRendered: (route: string, appHTML: string, appCtx: ViteReactSSGContext) => Promise<unknown[]>;
+    transformState?: (state: any) => any;
     /**
      * Current router path on SSG, `undefined` on client side.
      */