@revealui/core 0.0.1-pre.0

package/dist/plugins/config/index.ts

@@ -0,0 +1,227 @@
+export { resolveRevealConfig };
+
+import pc from "@brillout/picocolors";
+import type { Plugin, ResolvedConfig } from "vite";
+import { getRevealConfig } from "../../core/processing/getters/getRevealConfig/index.js";
+import { isDev2 } from "../utils.js";
+import { assertRevealConfig } from "./assertRevealConfig.js";
+import { pickFirst } from "./pickFirst.js";
+import { resolveBase } from "./resolveBase.js";
+import {
+  ConfigRevealResolved,
+  ConfigRevealUserProvided,
+} from "../../types/interfaces/reveal.js";
+
+type PluginRevealResolveRevealConfig = Plugin & {
+  name: string;
+  enforce: string;
+  configResolved: Plugin["configResolved"] & {
+    (config: ResolvedConfig): void;
+  };
+};
+
+function resolveRevealConfig(
+  revealConfig: unknown,
+): PluginRevealResolveRevealConfig {
+  return {
+    name: "reveal:resolveRevealConfig",
+    enforce: "pre",
+    async configResolved(config: ResolvedConfig): Promise<void> {
+      const promise: Promise<ConfigRevealResolved> = getConfigRevealPromise(
+        revealConfig,
+        config,
+      );
+      (config as Record<string, unknown>).configRevealPromise = promise;
+      await promise;
+    },
+  };
+}
+
+async function getConfigRevealPromise(
+  revealConfig: unknown,
+  config: ResolvedConfig,
+): Promise<ConfigRevealResolved> {
+  const fromPluginOptions = (revealConfig ?? {}) as ConfigRevealUserProvided;
+
+  const fromViteConfig = ((config as Record<string, unknown>).reveal ??
+    {}) as ConfigRevealUserProvided;
+
+  const configs = [fromViteConfig];
+
+  assertRevealConfig(
+    fromViteConfig,
+    ({ prop, errMsg }) => `vite.config.js#reveal.${prop} ${errMsg}`,
+  );
+
+  const crawlWithGit = fromViteConfig.crawl?.git ?? null;
+
+  const { globalRevealConfig: fromPlusConfigFile } = await getRevealConfig(
+    config,
+    isDev2(config),
+    { crawlWithGit },
+  );
+
+  configs.push(fromPlusConfigFile);
+  assertRevealConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
+    // You might want to provide the path of the config file here
+    return `config ${pc.cyan(prop)} ${errMsg}`;
+  });
+
+  const { baseServer, baseAssets } = resolveBase(configs, config);
+
+  const configReveal: ConfigRevealResolved = {
+    disableAutoFullBuild:
+      pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+    prerender: resolvePrerenderOptions(configs),
+    includeAssetsImportedByServer:
+      pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+    baseServer,
+    baseAssets,
+    redirects: merge(configs.map((c) => c.redirects)) ?? {},
+    disableUrlNormalization:
+      pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+    trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false,
+    crawl: {
+      git: crawlWithGit,
+    },
+  };
+
+  return configReveal;
+}
+
+function resolvePrerenderOptions(
+  configs: ConfigRevealUserProvided[],
+): ConfigRevealResolved["prerender"] {
+  if (!configs.some((c) => c.prerender)) {
+    return false;
+  }
+  const configsPrerender = configs.map((c) => c.prerender).filter(isObject);
+  return {
+    partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+    noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+    parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+    disableAutoRun:
+      pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false,
+  };
+}
+
+function isObject<T>(p: T | boolean | undefined): p is T {
+  return typeof p === "object";
+}
+
+type Obj = Record<string, string>;
+function merge(objs: (Obj | undefined)[]): Obj {
+  const obj: Record<string, string> = {};
+  objs.forEach((e) => {
+    Object.assign(obj, e);
+  });
+  return obj;
+}
+
+// export { resolveRevealConfig }
+
+// import pc from "@brillout/picocolors"
+// import type { Plugin, ResolvedConfig } from "vite"
+// import type {
+//   ConfigRevealResolved,
+//   ConfigRevealUserProvided,
+// } from "../../../ConfigReveal.js"
+// import { isDev2 } from "../../utils.js"
+// import { getRevealConfig } from "../importUserCode/v1-design/getRevealConfig.js"
+// import { assertRevealConfig } from "./assertRevealConfig.js"
+// import { pickFirst } from "./pickFirst.js"
+// import { resolveBase } from "./resolveBase.js"
+
+// function resolveRevealConfig(revealConfig: unknown): Plugin {
+//   return {
+//     name: "reveal:resolveRevealConfig",
+//     enforce: "pre",
+//     async configResolved(config) {
+//       const promise = getConfigRevealPromise(revealConfig, config)
+//       ;(config as Record<string, unknown>).configRevealPromise = promise
+//       await promise
+//     },
+//   }
+// }
+
+// async function getConfigRevealPromise(
+//   revealConfig: unknown,
+//   config: ResolvedConfig
+// ): Promise<ConfigRevealResolved> {
+//   const fromPluginOptions = (revealConfig ?? {}) as ConfigRevealUserProvided
+//   const fromViteConfig = ((config as Record<string, unknown>).reveal ??
+//     {}) as ConfigRevealUserProvided
+
+//   const configs = [fromPluginOptions, fromViteConfig]
+//   assertRevealConfig(
+//     fromViteConfig,
+//     ({ prop, errMsg }) => `vite.config.js#reveal.${prop} ${errMsg}`
+//   )
+//   // TODO/v1-release: deprecate this
+//   assertRevealConfig(
+//     fromPluginOptions,
+//     ({ prop, errMsg }) => `vite.config.js > reveal option ${prop} ${errMsg}`
+//   )
+
+//   const crawlWithGit = fromPluginOptions.crawl?.git ?? null
+//   const { globalRevealConfig: fromPlusConfigFile } = await getRevealConfig(
+//     config,
+//     isDev2(config),
+//     { crawlWithGit }
+//   )
+//   configs.push(fromPlusConfigFile)
+//   assertRevealConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
+//     // TODO: add config file path ?
+//     return `config ${pc.cyan(prop)} ${errMsg}`
+//   })
+
+//   const { baseServer, baseAssets } = resolveBase(configs, config)
+
+//   const configReveal: ConfigRevealResolved = {
+//     disableAutoFullBuild:
+//       pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+//     prerender: resolvePrerenderOptions(configs),
+//     includeAssetsImportedByServer:
+//       pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+//     baseServer,
+//     baseAssets,
+//     redirects: merge(configs.map((c) => c.redirects)) ?? {},
+//     disableUrlNormalization:
+//       pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+//     trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false,
+//     crawl: {
+//       git: crawlWithGit,
+//     },
+//   }
+
+//   return configReveal
+// }
+
+// function resolvePrerenderOptions(
+//   configs: ConfigRevealUserProvided[]
+// ): ConfigRevealResolved["prerender"] {
+//   if (!configs.some((c) => c.prerender)) {
+//     return false
+//   }
+//   const configsPrerender = configs.map((c) => c.prerender).filter(isObject)
+//   return {
+//     partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+//     noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+//     parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+//     disableAutoRun:
+//       pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false,
+//   }
+// }
+
+// function isObject<T>(p: T | boolean | undefined): p is T {
+//   return typeof p === "object"
+// }
+
+// type Obj = Record<string, string>
+// function merge(objs: (Obj | undefined)[]): Obj {
+//   const obj: Record<string, string> = {}
+//   objs.forEach((e) => {
+//     Object.assign(obj, e)
+//   })
+//   return obj
+// }

package/dist/plugins/config/pickFirst.ts

@@ -0,0 +1,3 @@
+export function pickFirst<T>(arr: T[]): T | undefined {
+  return arr.filter((v) => v !== undefined)[0];
+}

package/dist/plugins/config/resolveBase.ts

@@ -0,0 +1,78 @@
+export { resolveBase, resolveBaseFromUserConfig };
+
+import pc from "@brillout/picocolors";
+import type { ResolvedConfig, UserConfig } from "vite";
+import { assert, assertUsage, isBaseAssets, isBaseServer } from "../utils.js";
+import { pickFirst } from "./pickFirst.js";
+import type { ConfigRevealUserProvided } from "../../types/interfaces/reveal.js";
+
+type BaseServers = {
+  baseServer: string;
+  baseAssets: string;
+};
+
+function resolveBase(
+  configs: ConfigRevealUserProvided[],
+  config: ResolvedConfig,
+): BaseServers {
+  const baseServer = pickFirst(configs.map((c) => c.baseServer)) ?? null;
+  const baseAssets = pickFirst(configs.map((c) => c.baseAssets)) ?? null;
+  let baseOriginal: unknown = (config as Record<string, unknown>)._baseOriginal;
+  if (baseOriginal === "/__UNSET__") baseOriginal = null;
+  assert(baseOriginal === null || typeof baseOriginal == "string");
+  return resolve(baseOriginal, baseServer, baseAssets);
+}
+
+function resolveBaseFromUserConfig(
+  config: UserConfig,
+  configReveal: undefined | ConfigRevealUserProvided,
+): BaseServers {
+  return resolve(
+    config.base ?? null,
+    configReveal?.baseServer ?? null,
+    configReveal?.baseAssets ?? null,
+  );
+}
+
+function resolve(
+  base: string | null,
+  baseServer_: string | null,
+  baseAssets_: string | null,
+): BaseServers {
+  {
+    const wrongBase = (val: string) =>
+      `should start with ${pc.cyan("/")}, ${pc.cyan("http://")}, or ${pc.cyan("https://")} (it's ${pc.cyan(
+        val,
+      )} instead)`;
+    assertUsage(
+      base === null || isBaseAssets(base),
+      `vite.config.js#base ${wrongBase(base!)}`,
+    );
+    assertUsage(
+      baseAssets_ === null || isBaseAssets(baseAssets_),
+      `Config ${pc.cyan("baseAssets")} ${wrongBase(baseAssets_!)}`,
+    );
+    assertUsage(
+      baseServer_ === null || baseServer_.startsWith("/"),
+      `Config ${pc.cyan("baseServer")} should start with a leading slash ${pc.cyan("/")} (it's ${pc.cyan(
+        String(baseServer_),
+      )} instead)`,
+    );
+  }
+  if (base) {
+    if (base.startsWith("http")) {
+      baseAssets_ = baseAssets_ ?? base;
+    } else {
+      baseAssets_ = baseAssets_ ?? base;
+      baseServer_ = baseServer_ ?? base;
+    }
+  }
+  const baseServer = baseServer_ ?? "/";
+  const baseAssets = baseAssets_ ?? "/";
+  assert(isBaseAssets(baseAssets));
+  assert(isBaseServer(baseServer));
+  return {
+    baseServer,
+    baseAssets,
+  };
+}

package/dist/plugins/devConfig/determineFsAllowList.ts

@@ -0,0 +1,34 @@
+export { determineFsAllowList };
+
+import { createRequire } from "module";
+import path, { dirname } from "path";
+import { fileURLToPath } from "url";
+import type { ResolvedConfig } from "vite";
+import { searchForWorkspaceRoot } from "vite";
+import { assert } from "../utils.js";
+
+const importMetaUrl: string = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+const __dirname_ = dirname(fileURLToPath(importMetaUrl));
+
+async function determineFsAllowList(config: ResolvedConfig) {
+  const fsAllow = config.server.fs.allow;
+
+  // fsAllow should already contain searchForWorkspaceRoot()
+  assert(fsAllow.length >= 1);
+
+  fsAllow.push(process.cwd());
+
+  fsAllow.push(searchForWorkspaceRoot(process.cwd()));
+
+  // Add node_modules/reveal/
+  {
+    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/reveal/dist/node/plugin/plugins/config/
+    const revealRoot = path.join(__dirname_, "../../../../../../");
+    // Assert that `revealRoot` is indeed pointing to `node_modules/reveal/`
+    require_.resolve(
+      `${revealRoot}/dist/node/plugin/plugins/devConfig/index.js`,
+    );
+    fsAllow.push(revealRoot);
+  }
+}

package/dist/plugins/devConfig/determineOptimizeDeps.ts

@@ -0,0 +1,129 @@
+export { determineOptimizeDeps }
+
+import type { ResolvedConfig } from "vite"
+import { getRevealConfig } from "../../core/processing/getters/getRevealConfig/index.js"
+import { analyzeClientEntries } from "../buildConfig/index.js"
+
+import {
+  assert,
+  assertIsNpmPackageImport,
+  createDebugger,
+  isArray,
+  unique,
+} from "../utils.js"
+
+import {
+  virtualFileIdImportUserCodeClientCR,
+  virtualFileIdImportUserCodeClientSR,
+} from "../../core/files/virtual-files/virtualFileImportUserCode.js"
+import { PageConfigBuildTime } from "../../types/interfaces/page.js"
+
+const debug = createDebugger("reveal:optimizeDeps")
+
+async function determineOptimizeDeps(config: ResolvedConfig, isDev: true) {
+  const { pageConfigs } = await getRevealConfig(config, isDev)
+
+  const { entries, include } = await getPageDeps(config, pageConfigs, isDev)
+  {
+    // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
+    //  - Should we make it work? E.g. by creating a temporary file at node_modules/.reveal/virtualFiles.js
+    //  - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
+    //    - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    const entriesVirtualFiles = getVirtualFiles(config, pageConfigs)
+    entries.push(...(entriesVirtualFiles as string[]))
+  }
+
+  /* Other Vite plugins may populate optimizeDeps, e.g. Cypress: https://github.com/revealjs/reveal/issues/386
+  assert(config.optimizeDeps.entries === undefined)
+  */
+  config.optimizeDeps.include = [
+    ...include,
+    ...normalizeInclude(config.optimizeDeps.include),
+  ]
+  config.optimizeDeps.entries = [
+    ...entries,
+    ...normalizeEntries(config.optimizeDeps.entries),
+  ]
+
+  if (debug.isActivated)
+    debug("config.optimizeDeps", {
+      "config.optimizeDeps.entries": config.optimizeDeps.entries,
+      "config.optimizeDeps.include": config.optimizeDeps.include,
+    })
+}
+
+async function getPageDeps(
+  config: ResolvedConfig,
+  pageConfigs: PageConfigBuildTime[],
+  isDev: true
+) {
+  let entries: string[] = []
+  let include: string[] = []
+
+  const addEntry = (e: string) => {
+    assert(e)
+    entries.push(e)
+  }
+  const addInclude = (e: string) => {
+    assert(e)
+    // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
+    assertIsNpmPackageImport(e)
+    include.push(e)
+  }
+
+  // V1 design
+  {
+    pageConfigs.forEach((pageConfig) => {
+      Object.values(pageConfig.configValueSources).forEach((sources) => {
+        sources
+          .filter((c) => !c.isOverriden)
+          .forEach((configValueSource) => {
+            if (!configValueSource.valueIsImportedAtRuntime) return
+            const { definedAtFilePath, configEnv } = configValueSource
+
+            if (!configEnv.client) return
+
+            if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+              // Vite expects entries to be filesystem absolute paths (surprisingly so).
+              addEntry(definedAtFilePath.filePathAbsoluteFilesystem)
+            } else {
+              // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+              addInclude(definedAtFilePath.importPathAbsolute)
+            }
+          })
+      })
+    })
+  }
+
+  entries = unique(entries)
+  include = unique(include)
+  return { entries, include }
+}
+
+function getVirtualFiles(
+  config: ResolvedConfig,
+  pageConfigs: PageConfigBuildTime[]
+): string[] {
+  const { hasClientRouting, hasServerRouting, clientEntries } =
+    analyzeClientEntries(pageConfigs, config)
+
+  const entriesVirtualFiles = Object.values(clientEntries)
+  if (hasClientRouting)
+    entriesVirtualFiles.push(virtualFileIdImportUserCodeClientCR)
+  if (hasServerRouting)
+    entriesVirtualFiles.push(virtualFileIdImportUserCodeClientSR)
+
+  return entriesVirtualFiles as string[]
+}
+
+function normalizeEntries(entries: string | string[] | undefined) {
+  if (isArray(entries)) return entries
+  if (typeof entries === "string") return [entries]
+  if (entries === undefined) return []
+  assert(false)
+}
+function normalizeInclude(include: string[] | undefined) {
+  if (isArray(include)) return include
+  if (include === undefined) return []
+  assert(false)
+}

package/dist/plugins/devConfig/index.ts

@@ -0,0 +1,222 @@
+export { devConfig }
+
+import type { Plugin, ResolvedConfig, UserConfig } from "vite"
+
+import { improveViteLogs } from "../../core/gaurds/logger/loggerVite.js"
+import { isErrorDebug } from "../../core/gaurds/validators/isErrorDebug.js"
+import { installHttpRequestAsyncStore } from "../../core/processing/getters/getHttpRequestAsyncStore.js"
+import { addSsrMiddleware } from "../../core/targets/server/middleware/addSsrMiddleware.js"
+import { markEnvAsViteDev } from "../utils.js"
+import { determineFsAllowList } from "./determineFsAllowList.js"
+import { determineOptimizeDeps } from "./determineOptimizeDeps.js"
+
+type PluginDevConfig = Plugin &
+  {
+    name: string
+    apply: string
+    enforce?: string
+    config?: {
+      order?: string
+      handler?: () => UserConfig | undefined
+    }
+    configResolved?: (config: ResolvedConfig) => void
+    configureServer?: {
+      order?: string
+      handler: (server: import("vite").ViteDevServer) => void | (() => void)
+    }
+  }[]
+
+if (isErrorDebug()) {
+  Error.stackTraceLimit = Infinity
+}
+
+// There doesn't seem to be a straightforward way to discriminate between `$ vite preview` and `$ vite dev`
+const apply = "serve"
+const isDev = true
+
+function devConfig(): PluginDevConfig {
+  let config: ResolvedConfig
+  return [
+    {
+      name: "reveal:devConfig",
+      apply,
+      config: {
+        handler() {
+          return {
+            appType: "custom",
+            // Cleaned up optimizeDeps as per TODO
+            optimizeDeps: {
+              exclude: [
+                // Exclude Reveal's client runtime for Vite's import.meta.glob()
+                "reveal/client",
+                "reveal/client/router",
+                // Exclude imports to prevent loading issues
+                "reveal/routing",
+                "reveal/getPageContext",
+                // Exclude json-serializer and picocolors to avoid unnecessary reloads
+                "@brillout/json-serializer/parse",
+                "@brillout/json-serializer/stringify",
+                "@brillout/picocolors",
+                // Exclude react-streaming to resolve dependencies correctly
+                "react-streaming",
+              ],
+            },
+          } satisfies UserConfig
+        },
+      },
+      async configResolved(config_: ResolvedConfig): Promise<void> {
+        config = config_
+        await determineOptimizeDeps(config, isDev)
+        await determineFsAllowList(config)
+        if (!isErrorDebug()) {
+          await installHttpRequestAsyncStore()
+          improveViteLogs(config)
+        }
+      },
+      configureServer: {
+        handler() {
+          markEnvAsViteDev()
+        },
+      },
+    },
+    {
+      name: "reveal:devConfig:addSsrMiddleware",
+      apply,
+      // The SSR middleware should be last middleware
+      enforce: "post",
+      configureServer: {
+        order: "post",
+        handler(server: import("vite").ViteDevServer) {
+          const hasHonoViteDevServer: boolean = !!config.plugins.find(
+            (p): boolean => (p as any).name === "@hono/vite-dev-server"
+          )
+
+          if (config.server.middlewareMode || hasHonoViteDevServer) return
+          return (): void => {
+            addSsrMiddleware(server.middlewares, config, false)
+          }
+        },
+      },
+      // Setting `configResolved.clearScreen = false` doesn't work
+      config: {
+        order: "post",
+        handler() {
+          if (isErrorDebug()) {
+            return { clearScreen: false }
+          }
+        },
+      },
+    },
+  ]
+}
+
+// export { devConfig }
+
+// import type { Plugin, ResolvedConfig, UserConfig } from "vite"
+// import { isErrorDebug } from "../../isErrorDebug.js"
+// import { addSsrMiddleware } from "../addSsrMiddleware.js"
+// import { installHttpRequestAsyncStore } from "../getHttpRequestAsyncStore.js"
+// import { improveViteLogs } from "../loggerVite.js"
+// import { markEnvAsViteDev } from "../../utils.js"
+// import { determineFsAllowList } from "./determineFsAllowList.js"
+// import { determineOptimizeDeps } from "./determineOptimizeDeps.js"
+
+// if (isErrorDebug()) {
+//   Error.stackTraceLimit = Infinity
+// }
+
+// // There doesn't seem to be a straightforward way to discriminate between `$ vite preview` and `$ vite dev`
+// const apply = "serve"
+// const isDev = true
+
+// function devConfig(): Plugin[] {
+//   let config: ResolvedConfig
+//   return [
+//     {
+//       name: "reveal:devConfig",
+//       apply,
+//       config() {
+//         return {
+//           appType: "custom",
+//           // TODO:v1-release: remove (AFAICT we only need to use config.optimizeDeps for the old design)
+//           optimizeDeps: {
+//             exclude: [
+//               // We exclude Reveal's client runtime to be able to use Vite's import.meta.glob()
+//               "reveal/client",
+//               "reveal/client/router",
+
+//               // It seems like client-side/isomorphic imports also need to be excluded, in order to avoid the following:
+//               //   ```
+//               //   Client runtime loaded twice
+//               //   ```
+//               "reveal/routing",
+//               "reveal/getPageContext",
+
+//               // We exclude @brillout/json-serializer and @brillout/picocolors to avoid:
+//               // ```
+//               // 9:28:58 AM [vite] ✨ new dependencies optimized: @brillout/json-serializer/parse
+//               // 9:28:58 AM [vite] ✨ optimized dependencies changed. reloading
+//               // ```
+//               "@brillout/json-serializer/parse",
+//               "@brillout/json-serializer/stringify",
+//               "@brillout/picocolors",
+
+//               // We exclude all packages that depend on any optimizeDeps.exclude entry because, otherwise, the entry cannot be resolved when using pnpm. For example:
+//               // ```
+//               // Failed to resolve import "@brillout/json-serializer/parse" from "../../packages/reveal-react-query/dist/renderer/revealReactQueryWrapper.js". Does the file exist?
+//               // 343|  // ../../node_modules/.pnpm/react-streaming@0.3.16_react-dom@18.2.0_react@18.2.0/node_modules/react-streaming/dist/client/useAsync.js
+//               // 344|  import { parse as parse2 } from "@brillout/json-serializer/parse";
+//               // ```
+//               // The source map is confusing, the import actually lives at node_modules/.vite/deps/reveal-react-query_renderer_revealReactQueryWrapper.js which contains:
+//               // ```js
+//               // // ../../node_modules/.pnpm/react-streaming@0.3.16_react-dom@18.2.0_react@18.2.0/node_modules/react-streaming/dist/client/useAsync.js
+//               // import { parse as parse2 } from "@brillout/json-serializer/parse";
+//               // ```
+//               "react-streaming",
+//             ],
+//           },
+//         } satisfies UserConfig
+//       },
+//       async configResolved(config_) {
+//         config = config_
+//         await determineOptimizeDeps(config, isDev)
+//         await determineFsAllowList(config)
+//         if (!isErrorDebug()) {
+//           await installHttpRequestAsyncStore()
+//           improveViteLogs(config)
+//         }
+//       },
+//       configureServer() {
+//         markEnvAsViteDev()
+//       },
+//     },
+//     {
+//       name: "reveal:devConfig:addSsrMiddleware",
+//       apply,
+//       // The SSR middleware should be last middleware
+//       enforce: "post",
+//       configureServer: {
+//         order: "post",
+//         handler(server) {
+//           const hasHonoViteDevServer = !!config.plugins.find(
+//             (p) => p.name === "@hono/vite-dev-server"
+//           )
+
+//           if (config.server.middlewareMode || hasHonoViteDevServer) return
+//           return () => {
+//             addSsrMiddleware(server.middlewares, config, false)
+//           }
+//         },
+//       },
+//       // Setting `configResolved.clearScreen = false` doesn't work
+//       config: {
+//         order: "post",
+//         handler() {
+//           if (isErrorDebug()) {
+//             return { clearScreen: false }
+//           }
+//         },
+//       },
+//     },
+//   ]
+// }