vite-react-ssg 0.0.3 → 0.1.1

package/dist/node/cli.cjs

@@ -3,7 +3,7 @@
 const kolorist = require('kolorist');
 const yargs = require('yargs');
 const helpers = require('yargs/helpers');
-const build = require('../shared/vite-react-ssg.a5dfecac.cjs');
+const dev = require('../shared/vite-react-ssg.8cbf43cc.cjs');
 require('node:path');
 require('node:module');
 require('fs-extra');
@@ -12,6 +12,8 @@ require('jsdom');
 require('../shared/vite-react-ssg.4ca822c0.cjs');
 require('react');
 require('react-helmet-async');
+require('express');
+require('node:fs');
 require('react-router-dom/server.js');
 require('node:stream');
 require('react-dom/server');
@@ -20,7 +22,7 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const yargs__default = /*#__PURE__*/_interopDefaultCompat(yargs);
 
-yargs__default(helpers.hideBin(process.argv)).scriptName("vite-ssg").usage("$0 [args]").command(
+yargs__default(helpers.hideBin(process.argv)).scriptName("vite-react-ssg").usage("$0 [args]").command(
   "build",
   "Build SSG",
   (args) => args.option("script", {
@@ -40,11 +42,33 @@ yargs__default(helpers.hideBin(process.argv)).scriptName("vite-ssg").usage("$0 [
   }),
   async (args) => {
     const { config: configFile = void 0, ...ssgOptions } = args;
-    await build.build(ssgOptions, { configFile });
+    await dev.build(ssgOptions, { configFile });
+  }
+).command(
+  "dev",
+  "Dev SSG",
+  (args) => args.option("script", {
+    choices: ["sync", "async", "defer", "async defer"],
+    describe: "Rewrites script loading timing"
+  }).option("mock", {
+    type: "boolean",
+    describe: "Mock browser globals (window, document, etc.) for SSG"
+  }).option("config", {
+    alias: "c",
+    type: "string",
+    describe: "The vite config file to use"
+  }).option("base", {
+    alias: "b",
+    type: "string",
+    describe: "The base path to render"
+  }),
+  async (args) => {
+    const { config: configFile = void 0, ...ssgOptions } = args;
+    await dev.dev(ssgOptions, { configFile });
   }
 ).fail((msg, err, yargs2) => {
   console.error(`
-${kolorist.gray("[vite-ssg]")} ${kolorist.bold(kolorist.red("An internal error occurred."))}`);
-  console.error(`${kolorist.gray("[vite-ssg]")} ${kolorist.reset(`Please report an issue, if none already exists: ${kolorist.underline("https://github.com/antfu/vite-ssg/issues")}`)}`);
+${kolorist.gray("[vite-react-ssg]")} ${kolorist.bold(kolorist.red("An internal error occurred."))}`);
+  console.error(`${kolorist.gray("[vite-react-ssg]")} ${kolorist.reset(`Please report an issue, if none already exists: ${kolorist.underline("https://github.com/daydreamer-riri/vite-react-ssg/issues")}`)}`);
   yargs2.exit(1, err);
 }).showHelpOnFail(false).help().argv;

package/dist/node/cli.mjs

@@ -1,7 +1,7 @@
 import { gray, bold, red, reset, underline } from 'kolorist';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { b as build } from '../shared/vite-react-ssg.524ba00d.mjs';
+import { b as build, d as dev } from '../shared/vite-react-ssg.5291bf32.mjs';
 import 'node:path';
 import 'node:module';
 import 'fs-extra';
@@ -10,11 +10,13 @@ import 'jsdom';
 import '../shared/vite-react-ssg.9d005d5e.mjs';
 import 'react';
 import 'react-helmet-async';
+import 'express';
+import 'node:fs';
 import 'react-router-dom/server.js';
 import 'node:stream';
 import 'react-dom/server';
 
-yargs(hideBin(process.argv)).scriptName("vite-ssg").usage("$0 [args]").command(
+yargs(hideBin(process.argv)).scriptName("vite-react-ssg").usage("$0 [args]").command(
   "build",
   "Build SSG",
   (args) => args.option("script", {
@@ -36,9 +38,31 @@ yargs(hideBin(process.argv)).scriptName("vite-ssg").usage("$0 [args]").command(
     const { config: configFile = void 0, ...ssgOptions } = args;
     await build(ssgOptions, { configFile });
   }
+).command(
+  "dev",
+  "Dev SSG",
+  (args) => args.option("script", {
+    choices: ["sync", "async", "defer", "async defer"],
+    describe: "Rewrites script loading timing"
+  }).option("mock", {
+    type: "boolean",
+    describe: "Mock browser globals (window, document, etc.) for SSG"
+  }).option("config", {
+    alias: "c",
+    type: "string",
+    describe: "The vite config file to use"
+  }).option("base", {
+    alias: "b",
+    type: "string",
+    describe: "The base path to render"
+  }),
+  async (args) => {
+    const { config: configFile = void 0, ...ssgOptions } = args;
+    await dev(ssgOptions, { configFile });
+  }
 ).fail((msg, err, yargs2) => {
   console.error(`
-${gray("[vite-ssg]")} ${bold(red("An internal error occurred."))}`);
-  console.error(`${gray("[vite-ssg]")} ${reset(`Please report an issue, if none already exists: ${underline("https://github.com/antfu/vite-ssg/issues")}`)}`);
+${gray("[vite-react-ssg]")} ${bold(red("An internal error occurred."))}`);
+  console.error(`${gray("[vite-react-ssg]")} ${reset(`Please report an issue, if none already exists: ${underline("https://github.com/daydreamer-riri/vite-react-ssg/issues")}`)}`);
   yargs2.exit(1, err);
 }).showHelpOnFail(false).help().argv;

package/dist/node.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const build = require('./shared/vite-react-ssg.a5dfecac.cjs');
+const dev = require('./shared/vite-react-ssg.8cbf43cc.cjs');
 require('node:path');
 require('node:module');
 require('kolorist');
@@ -10,10 +10,13 @@ require('jsdom');
 require('./shared/vite-react-ssg.4ca822c0.cjs');
 require('react');
 require('react-helmet-async');
+require('express');
+require('node:fs');
 require('react-router-dom/server.js');
 require('node:stream');
 require('react-dom/server');
 
 
 
-exports.build = build.build;
+exports.build = dev.build;
+exports.dev = dev.dev;

package/dist/node.d.ts

@@ -1,8 +1,11 @@
 import { InlineConfig } from 'vite';
-import { b as ViteReactSSGOptions } from './types-82f34756.js';
+import { b as ViteReactSSGOptions } from './types-408e974a.js';
 import 'critters';
+import 'react';
 import 'react-router-dom';
 
 declare function build(ssgOptions?: Partial<ViteReactSSGOptions>, viteConfig?: InlineConfig): Promise<void>;
 
-export { build };
+declare function dev(ssgOptions?: Partial<ViteReactSSGOptions>, viteConfig?: InlineConfig): Promise<void>;
+
+export { build, dev };

package/dist/node.mjs

@@ -1,4 +1,4 @@
-export { b as build } from './shared/vite-react-ssg.524ba00d.mjs';
+export { b as build, d as dev } from './shared/vite-react-ssg.5291bf32.mjs';
 import 'node:path';
 import 'node:module';
 import 'kolorist';
@@ -8,6 +8,8 @@ import 'jsdom';
 import './shared/vite-react-ssg.9d005d5e.mjs';
 import 'react';
 import 'react-helmet-async';
+import 'express';
+import 'node:fs';
 import 'react-router-dom/server.js';
 import 'node:stream';
 import 'react-dom/server';

package/dist/shared/{vite-react-ssg.524ba00d.mjs → vite-react-ssg.5291bf32.mjs}

@@ -1,10 +1,12 @@
 import { join, isAbsolute, parse, dirname } from 'node:path';
 import { createRequire } from 'node:module';
-import { gray, yellow, blue, dim, cyan, red, green } from 'kolorist';
+import { gray, yellow, blue, dim, cyan, red, green, bold, reset, bgLightCyan } from 'kolorist';
 import fs from 'fs-extra';
-import { resolveConfig, build as build$1, mergeConfig } from 'vite';
+import { resolveConfig, build as build$1, mergeConfig, createServer, version as version$1 } from 'vite';
 import { JSDOM } from 'jsdom';
 import { S as SiteMetadataDefaults, s as serializeState } from './vite-react-ssg.9d005d5e.mjs';
+import express from 'express';
+import { readFileSync } from 'node:fs';
 import React from 'react';
 import { HelmetProvider } from 'react-helmet-async';
 import { createStaticHandler, createStaticRouter, StaticRouterProvider } from 'react-router-dom/server.js';
@@ -893,6 +895,39 @@ function routesToPaths(routes) {
   getPaths(routes);
   return { paths: Array.from(paths), pathToEntry };
 }
+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);
+  return result || join(config.root, entry);
+}
+const { version } = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url)).toString()
+);
 
 async function getCritters(outDir, options = {}) {
   try {
@@ -955,14 +990,16 @@ class WritableAsPromise extends Writable {
   }
 }
 
-async function render(routes, request) {
+async function render(routes, request, styleCollector) {
   const { dataRoutes, query } = createStaticHandler(routes);
   const context = await query(request);
   const helmetContext = {};
   if (context instanceof Response)
     throw context;
   const router = createStaticRouter(dataRoutes, context);
-  const app = /* @__PURE__ */ React.createElement(HelmetProvider, { context: helmetContext }, /* @__PURE__ */ React.createElement(SiteMetadataDefaults, null), /* @__PURE__ */ React.createElement(StaticRouterProvider, { router, context }));
+  let app = /* @__PURE__ */ React.createElement(HelmetProvider, { context: helmetContext }, /* @__PURE__ */ React.createElement(SiteMetadataDefaults, null), /* @__PURE__ */ React.createElement(StaticRouterProvider, { router, context }));
+  if (styleCollector)
+    app = styleCollector.collect(app);
   const appHTML = await renderStaticApp(app);
   const { helmet } = helmetContext;
   const htmlAttributes = helmet.htmlAttributes.toString();
@@ -973,6 +1010,8 @@ async function render(routes, request) {
     helmet.link.toString(),
     helmet.script.toString()
   ];
+  const styleTag = styleCollector?.toString?.(appHTML) ?? "";
+  metaStrings.push(styleTag);
   const metaAttributes = metaStrings.filter(Boolean);
   return { appHTML, htmlAttributes, bodyAttributes, metaAttributes };
 }
@@ -1010,7 +1049,7 @@ function renderPreloadLink(document, file) {
     });
   }
 }
-function createLink(document) {
+function createLink$1(document) {
   return document.createElement("link");
 }
 function setAttrs(el, attrs) {
@@ -1022,11 +1061,68 @@ function appendLink(document, attrs) {
   const exits = document.head.querySelector(`link[href='${attrs.file}']`);
   if (exits)
     return;
-  const link = createLink(document);
+  const link = createLink$1(document);
   setAttrs(link, attrs);
   document.head.appendChild(link);
 }
 
+async function renderHTML({
+  rootContainerId,
+  indexHTML,
+  appHTML,
+  metaAttributes,
+  bodyAttributes,
+  htmlAttributes,
+  initialState
+}) {
+  const stateScript = initialState ? `
+<script>window.__INITIAL_STATE__=${initialState}<\/script>` : "";
+  const headStartTag = "<head>";
+  const metaTags = metaAttributes.join("");
+  indexHTML = indexHTML.replace(headStartTag, headStartTag + metaTags);
+  const bodyStartTag = "<body";
+  indexHTML = indexHTML.replace(bodyStartTag, `${bodyStartTag} ${bodyAttributes}`);
+  const htmlStartTag = "<html";
+  indexHTML = indexHTML.replace(htmlStartTag, `${htmlStartTag} ${htmlAttributes}`);
+  const container = `<div id="${rootContainerId}"></div>`;
+  if (indexHTML.includes(container)) {
+    return indexHTML.replace(
+      container,
+      `<div id="${rootContainerId}" data-server-rendered="true">${appHTML}</div>${stateScript}`
+    );
+  }
+  const html5Parser = await import('html5parser');
+  const ast = html5Parser.parse(indexHTML);
+  let renderedOutput;
+  html5Parser.walk(ast, {
+    enter: (node) => {
+      if (!renderedOutput && node?.type === html5Parser.SyntaxKind.Tag && Array.isArray(node.attributes) && node.attributes.length > 0 && node.attributes.some((attr) => attr.name.value === "id" && attr.value?.value === rootContainerId)) {
+        const attributesStringified = [...node.attributes.map(({ name: { value: name }, value }) => `${name}="${value.value}"`)].join(" ");
+        const indexHTMLBefore = indexHTML.slice(0, node.start);
+        const indexHTMLAfter = indexHTML.slice(node.end);
+        renderedOutput = `${indexHTMLBefore}<${node.name} ${attributesStringified} data-server-rendered="true">${appHTML}</${node.name}>${stateScript}${indexHTMLAfter}`;
+      }
+    }
+  });
+  if (!renderedOutput)
+    throw new Error(`Could not find a tag with id="${rootContainerId}" to replace it with server-side rendered HTML`);
+  return renderedOutput;
+}
+async function detectEntry(root) {
+  const scriptSrcReg = /<script(?:.*?)src=["'](.+?)["'](?!<)(?:.*)\>(?:[\n\r\s]*?)(?:<\/script>)/img;
+  const html = await fs.readFile(join(root, "index.html"), "utf-8");
+  const scripts = [...html.matchAll(scriptSrcReg)];
+  const [, entry] = scripts.find((matchResult) => {
+    const [script] = matchResult;
+    const [, scriptType] = script.match(/.*\stype=(?:'|")?([^>'"\s]+)/i) || [];
+    return scriptType === "module";
+  }) || [];
+  return entry || "src/main.ts";
+}
+function createLink(href) {
+  return `<link rel="stylesheet" href="${href}">`;
+}
+
 function DefaultIncludedRoutes(paths, _routes) {
   return paths.filter((i) => !i.includes(":") && !i.includes("*"));
 }
@@ -1117,19 +1213,20 @@ async function build(ssgOptions = {}, viteConfig = {}) {
     queue.add(async () => {
       try {
         const appCtx = await createRoot(false, route);
-        const { routes: routes2, initialState, triggerOnSSRAppRendered, transformState = serializeState } = appCtx;
-        const transformedIndexHTML = await onBeforePageRender?.(route, indexHTML, appCtx);
+        const { routes: routes2, initialState, triggerOnSSRAppRendered, transformState = serializeState, getStyleCollector } = appCtx;
+        const styleCollector = getStyleCollector ? await getStyleCollector() : null;
+        const transformedIndexHTML = await onBeforePageRender?.(route, indexHTML, appCtx) || indexHTML;
         const url = new URL(route, "http://vite-react-ssg.com");
         url.search = "";
         url.hash = "";
         url.pathname = route;
         const request = new Request(url.href);
-        const { appHTML, bodyAttributes, htmlAttributes, metaAttributes } = await render([...routes2], request);
+        const { appHTML, bodyAttributes, htmlAttributes, metaAttributes } = await render([...routes2], request, styleCollector);
         await triggerOnSSRAppRendered?.(route, appHTML, appCtx);
         const renderedHTML = await renderHTML({
           rootContainerId,
           appHTML,
-          indexHTML,
+          indexHTML: transformedIndexHTML,
           metaAttributes,
           bodyAttributes,
           htmlAttributes,
@@ -1173,69 +1270,11 @@ ${gray("[vite-react-ssg]")} ${green("Build finished.")}`);
   }, waitInSeconds * 1e3);
   timeout.unref();
 }
-async function detectEntry(root) {
-  const scriptSrcReg = /<script(?:.*?)src=["'](.+?)["'](?!<)(?:.*)\>(?:[\n\r\s]*?)(?:<\/script>)/img;
-  const html = await fs.readFile(join(root, "index.html"), "utf-8");
-  const scripts = [...html.matchAll(scriptSrcReg)];
-  const [, entry] = scripts.find((matchResult) => {
-    const [script] = matchResult;
-    const [, scriptType] = script.match(/.*\stype=(?:'|")?([^>'"\s]+)/i) || [];
-    return scriptType === "module";
-  }) || [];
-  return entry || "src/main.ts";
-}
-async function resolveAlias(config, entry) {
-  const resolver = config.createResolver();
-  const result = await resolver(entry, config.root);
-  return result || join(config.root, entry);
-}
 function rewriteScripts(indexHTML, mode) {
   if (!mode || mode === "sync")
     return indexHTML;
   return indexHTML.replace(/<script type="module" /g, `<script type="module" ${mode} `);
 }
-async function renderHTML({
-  rootContainerId,
-  indexHTML,
-  appHTML,
-  metaAttributes,
-  bodyAttributes,
-  htmlAttributes,
-  initialState
-}) {
-  const stateScript = initialState ? `
-<script>window.__INITIAL_STATE__=${initialState}<\/script>` : "";
-  const headStartTag = "<head>";
-  const metaTags = metaAttributes.join("");
-  indexHTML = indexHTML.replace(headStartTag, headStartTag + metaTags);
-  const bodyStartTag = "<body";
-  indexHTML = indexHTML.replace(bodyStartTag, `${bodyStartTag} ${bodyAttributes}`);
-  const htmlStartTag = "<html";
-  indexHTML = indexHTML.replace(htmlStartTag, `${htmlStartTag} ${htmlAttributes}`);
-  const container = `<div id="${rootContainerId}"></div>`;
-  if (indexHTML.includes(container)) {
-    return indexHTML.replace(
-      container,
-      `<div id="${rootContainerId}" data-server-rendered="true">${appHTML}</div>${stateScript}`
-    );
-  }
-  const html5Parser = await import('html5parser');
-  const ast = html5Parser.parse(indexHTML);
-  let renderedOutput;
-  html5Parser.walk(ast, {
-    enter: (node) => {
-      if (!renderedOutput && node?.type === html5Parser.SyntaxKind.Tag && Array.isArray(node.attributes) && node.attributes.length > 0 && node.attributes.some((attr) => attr.name.value === "id" && attr.value?.value === rootContainerId)) {
-        const attributesStringified = [...node.attributes.map(({ name: { value: name }, value }) => `${name}="${value.value}"`)].join(" ");
-        const indexHTMLBefore = indexHTML.slice(0, node.start);
-        const indexHTMLAfter = indexHTML.slice(node.end);
-        renderedOutput = `${indexHTMLBefore}<${node.name} ${attributesStringified} data-server-rendered="true">${appHTML}</${node.name}>${stateScript}${indexHTMLAfter}`;
-      }
-    }
-  });
-  if (!renderedOutput)
-    throw new Error(`Could not find a tag with id="${rootContainerId}" to replace it with server-side rendered HTML`);
-  return renderedOutput;
-}
 async function formatHtml(html, formatting) {
   if (formatting === "minify") {
     const htmlMinifier = await import('html-minifier');
@@ -1271,4 +1310,185 @@ function collectModules(manifest, entry, mods = /* @__PURE__ */ new Set()) {
   return mods;
 }
 
-export { build as b };
+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 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();
+  });
+}
+
+async function dev(ssgOptions = {}, viteConfig = {}) {
+  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 {
+    entry = await detectEntry(root),
+    onBeforePageRender,
+    onPageRendered,
+    rootContainerId = "root"
+  } = Object.assign({}, config.ssgOptions || {}, ssgOptions);
+  const ssrEntry = await resolveAlias(config, entry);
+  const template = await fs.readFile(join(root, "index.html"), "utf-8");
+  let viteServer;
+  globalThis.__ssr_start_time = performance.now();
+  createServer$1().then((app) => {
+    const port = viteServer.config.server.port || 5173;
+    const server = app.listen(port, () => {
+      printServerInfo(viteServer);
+      bindShortcuts(viteServer, server);
+    });
+  });
+  async function createServer$1() {
+    process.env.__DEV_MODE_SSR = "true";
+    const app = express();
+    viteServer = await createServer({
+      // ...options,
+      server: { middlewareMode: true },
+      appType: "custom"
+    });
+    app.use(viteServer.middlewares);
+    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 } = appCtx;
+        const transformedIndexHTML = await onBeforePageRender?.(url, indexHTML, appCtx) || indexHTML;
+        const styleCollector = getStyleCollector ? await getStyleCollector() : null;
+        const { appHTML, bodyAttributes, htmlAttributes, metaAttributes } = await render([...routes], createFetchRequest(req), styleCollector);
+        const mod = await viteServer.moduleGraph.getModuleByUrl(entry);
+        const assetsUrls = /* @__PURE__ */ new Set();
+        const collectAssets = async (mod2) => {
+          if (!mod2?.ssrTransformResult)
+            return;
+          const { deps = [], dynamicDeps = [] } = mod2?.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 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;
+  }
+}
+async function printServerInfo(server, onlyUrl = false) {
+  const info = server.config.logger.info;
+  const port = server.config.server.port || 5173;
+  const url = `http://localhost:${port}/`;
+  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(
+      `
+ ${bgLightCyan(` VITE-REACT-SSG v${version} `)}`,
+      { 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)}`);
+}
+
+export { build as b, dev as d };