@revealui/core 0.0.1-pre.0

package/dist/plugins/fileEnv.ts

@@ -0,0 +1,374 @@
+export { fileEnv }
+
+import pc from "@brillout/picocolors"
+import type { Plugin, ResolvedConfig, ViteDevServer } from "vite"
+import { extractAssetsRE } from "./extractAssetsPlugin.js"
+// import { extractExportNamesRE } from "./extractExportNamesPlugin.js";
+import { getModuleFilePathAbsolute } from "../core/processing/getters/getFilePath.js"
+import { getModuleExportNames } from "../core/processing/parsers/parseEsModule.js"
+import {
+  assert,
+  assertUsage,
+  assertWarning,
+  capitalizeFirstLetter,
+  joinEnglish,
+} from "./utils.js"
+
+type PluginFileEnv = Plugin & {
+  name: string
+  load(id: string, options: any): void
+  transform(code: string, id: string, options: any): Promise<string | void>
+  generateBundle(): void
+  configResolved(config: ResolvedConfig): void
+  configureServer(viteDevServer: ViteDevServer): void
+  getModuleInfo(id: string): {
+    importers: readonly string[]
+    dynamicImporters: readonly string[]
+  } | null
+  getModuleIds(): Set<string>
+}
+
+function fileEnv(): PluginFileEnv {
+  let config: ResolvedConfig
+  let viteDevServer: ViteDevServer | undefined
+  return {
+    name: "reveal:fileEnv",
+    getModuleInfo(id: string) {
+      if (!id) return null
+      if (!viteDevServer) return null
+      const moduleInfo = viteDevServer.moduleGraph.getModuleById(id)
+      if (!moduleInfo) return null
+      const importers = Array.from(moduleInfo.importers).map((m) => m.id || "")
+      const dynamicImporters = Array.from(moduleInfo.clientImportedModules).map(
+        (m) => m.id || ""
+      )
+      return {
+        importers: importers,
+        dynamicImporters: dynamicImporters,
+      }
+    },
+    getModuleIds() {
+      return new Set<string>()
+    },
+    load(id: string, options: { ssr: any }) {
+      // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+      if (!viteDevServer) return
+      if (skip(id)) return
+
+      if (id.endsWith("?direct")) id = id.slice(0, -1 * "?direct".length)
+      const moduleInfo = viteDevServer.moduleGraph.getModuleById(id)
+      assert(moduleInfo)
+      const importers: string[] = Array.from(moduleInfo.importers)
+        .map((m) => m.id)
+        .filter((id) => id !== null)
+      assertFileEnv(
+        id,
+        !!options?.ssr,
+        importers,
+        // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://reveal.dev/ssr).
+        true
+      )
+    },
+    // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
+    async transform(code: string, id: string, options: { ssr: any }) {
+      // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+      if (viteDevServer) return
+      if (skip(id)) return
+      const isServerSide = !!options?.ssr
+      if (!isWrongEnv(id, isServerSide)) return
+      const { importers } = this.getModuleInfo(id)!
+      // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
+      const errMsg = getErrorMessage(id, isServerSide, importers, false, true)
+      // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+      const { exportNames } = await getModuleExportNames(code)
+      return [
+        `throw new Error(${JSON.stringify(errMsg)});`,
+        ...exportNames.map((name) =>
+          name === "default"
+            ? "export default undefined;"
+            : `export const ${name} = undefined;`
+        ),
+      ].join("\n")
+    },
+    generateBundle() {
+      Array.from(this.getModuleIds())
+        .filter((id) => !skip(id))
+        .forEach((moduleId) => {
+          const { importers, dynamicImporters } = this.getModuleInfo(moduleId)!
+          if (importers.length === 0) {
+            // Dynamic imports can only be verified at runtime
+            assert(dynamicImporters.length > 0)
+            return
+          }
+          assertFileEnv(moduleId, !!config.build.ssr, importers, false)
+        })
+    },
+    configResolved(config_: ResolvedConfig) {
+      config = config_
+    },
+    configureServer(viteDevServer_: ViteDevServer) {
+      viteDevServer = viteDevServer_
+    },
+  }
+
+  function assertFileEnv(
+    moduleId: string,
+    isServerSide: boolean,
+    importers: string[] | readonly string[],
+    onlyWarn: boolean
+  ) {
+    if (!isWrongEnv(moduleId, isServerSide)) return
+    const errMsg = getErrorMessage(
+      moduleId,
+      isServerSide,
+      importers,
+      onlyWarn,
+      false
+    )
+    if (onlyWarn) {
+      assertWarning(false, errMsg, { onlyOnce: true })
+    } else {
+      assertUsage(false, errMsg)
+    }
+  }
+
+  function getErrorMessage(
+    moduleId: string,
+    isServerSide: boolean,
+    importers: string[] | readonly string[],
+    onlyWarn: boolean,
+    noColor: boolean
+  ) {
+    const modulePath = getModulePath(moduleId)
+
+    const envActual = isServerSide ? "server" : "client"
+    const envExpect = isServerSide ? "client" : "server"
+
+    let errMsg: string
+    let modulePathPretty = getModuleFilePathAbsolute(modulePath, config)
+    if (!noColor) {
+      const suffix = getSuffix(envExpect)
+      modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix))
+    }
+    errMsg = `${capitalizeFirstLetter(
+      envExpect
+    )}-only file ${modulePathPretty}  imported on the ${envActual}-side`
+
+    if (importers.length > 0) {
+      const importPaths = importers.map((importer) =>
+        getModuleFilePathAbsolute(importer, config)
+      )
+      errMsg += ` by ${joinEnglish(importPaths, "and")}`
+    }
+
+    if (onlyWarn) {
+      errMsg +=
+        " and, therefore, Reveal will prevent building your app for production."
+    }
+
+    return errMsg
+  }
+
+  function isWrongEnv(moduleId: string, isServerSide: boolean): boolean {
+    const modulePath = getModulePath(moduleId)
+    const suffixWrong = getSuffix(isServerSide ? "client" : "server")
+    return modulePath.includes(suffixWrong)
+  }
+
+  function skip(id: string): boolean {
+    // if (extractAssetsRE.test(id) || extractExportNamesRE.test(id)) return true;
+    if (extractAssetsRE.test(id)) return true
+    if (!id.includes(getSuffix("client")) && !id.includes(getSuffix("server")))
+      return true
+    if (getModulePath(id).endsWith(".css")) return true
+    // Apply `.server.js` and `.client.js` only to user files
+    if (id.includes("/node_modules/")) return true
+    // Only user files
+    if (!id.startsWith(config.root)) return true
+    return false
+  }
+
+  function getSuffix(env: "client" | "server") {
+    return `.${env}.` as const
+  }
+
+  function getModulePath(moduleId: string) {
+    return moduleId.split("?")[0]!
+  }
+}
+
+// export { fileEnv };
+
+// // Implementation for https://reveal.dev/file-env
+// // Alternative implementations:
+// // - Remix: https://github.com/remix-run/remix/blob/0e542779499b13ab9291cf20cd5e6b43e2905151/packages/remix-dev/vite/plugin.ts#L1504-L1594
+// // - SvelteKit: https://github.com/sveltejs/kit/blob/6ea7abbc2f66e46cb83ff95cd459a5f548cb7e1e/packages/kit/src/exports/vite/index.js#L383-L401
+
+// import type { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+// import {
+//   assert,
+//   assertUsage,
+//   assertWarning,
+//   capitalizeFirstLetter,
+//   joinEnglish,
+// } from "../utils.js";
+// import { extractAssetsRE } from "./extractAssetsPlugin.js";
+// import { extractExportNamesRE } from "./extractExportNamesPlugin.js";
+// import pc from "@brillout/picocolors";
+// import { getModuleFilePathAbsolute } from "../shared/getFilePath.js";
+// import { sourceMapRemove } from "../shared/rollupSourceMap.js";
+// import { getExportNames } from "../shared/parseEsModule.js";
+
+// function fileEnv(): Plugin {
+//   let config: ResolvedConfig;
+//   let viteDevServer: ViteDevServer | undefined;
+//   return {
+//     name: "reveal:fileEnv",
+//     load(id, options) {
+//       // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+//       if (!viteDevServer) return;
+//       if (skip(id)) return;
+//       // For `.vue` files: https://github.com/revealjs/reveal/issues/1912#issuecomment-2394981475
+//       if (id.endsWith("?direct")) id = id.slice(0, -1 * "?direct".length);
+//       const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
+//       assert(moduleInfo);
+//       const importers: string[] = Array.from(moduleInfo.importers)
+//         .map((m) => m.id)
+//         .filter((id) => id !== null);
+//       assertFileEnv(
+//         id,
+//         !!options?.ssr,
+//         importers,
+//         // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://reveal.dev/ssr).
+//         true,
+//       );
+//     },
+//     // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
+//     async transform(code, id, options) {
+//       // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+//       if (viteDevServer) return;
+//       if (skip(id)) return;
+//       const isServerSide = !!options?.ssr;
+//       if (!isWrongEnv(id, isServerSide)) return;
+//       const { importers } = this.getModuleInfo(id)!;
+//       // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code splitted.
+//       const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+//       // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+//       const { exportNames } = await getExportNames(code);
+//       return sourceMapRemove(
+//         [
+//           `throw new Error(${JSON.stringify(errMsg)});`,
+//           ...exportNames.map((name) =>
+//             name === "default"
+//               ? "export default undefined;"
+//               : `export const ${name} = undefined;`,
+//           ),
+//         ].join("\n"),
+//       );
+//     },
+//     generateBundle() {
+//       Array.from(this.getModuleIds())
+//         .filter((id) => !skip(id))
+//         .forEach((moduleId) => {
+//           const { importers, dynamicImporters } = this.getModuleInfo(moduleId)!;
+//           if (importers.length === 0) {
+//             // Dynamic imports can only be verified at runtime
+//             assert(dynamicImporters.length > 0);
+//             return;
+//           }
+//           assertFileEnv(moduleId, !!config.build.ssr, importers, false);
+//         });
+//     },
+//     configResolved(config_) {
+//       config = config_;
+//     },
+//     configureServer(viteDevServer_) {
+//       viteDevServer = viteDevServer_;
+//     },
+//   };
+
+//   function assertFileEnv(
+//     moduleId: string,
+//     isServerSide: boolean,
+//     importers: string[] | readonly string[],
+//     onlyWarn: boolean,
+//   ) {
+//     if (!isWrongEnv(moduleId, isServerSide)) return;
+//     const errMsg = getErrorMessage(
+//       moduleId,
+//       isServerSide,
+//       importers,
+//       onlyWarn,
+//       false,
+//     );
+//     if (onlyWarn) {
+//       assertWarning(false, errMsg, { onlyOnce: true });
+//     } else {
+//       assertUsage(false, errMsg);
+//     }
+//   }
+
+//   function getErrorMessage(
+//     moduleId: string,
+//     isServerSide: boolean,
+//     importers: string[] | readonly string[],
+//     onlyWarn: boolean,
+//     noColor: boolean,
+//   ) {
+//     const modulePath = getModulePath(moduleId);
+
+//     const envActual = isServerSide ? "server" : "client";
+//     const envExpect = isServerSide ? "client" : "server";
+
+//     let errMsg: string;
+//     let modulePathPretty = getModuleFilePathAbsolute(modulePath, config);
+//     if (!noColor) {
+//       const suffix = getSuffix(envExpect);
+//       modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
+//     }
+//     errMsg = `${capitalizeFirstLetter(
+//       envExpect,
+//     )}-only file ${modulePathPretty} (https://reveal.dev/file-env) imported on the ${envActual}-side`;
+
+//     if (importers.length > 0) {
+//       const importPaths = importers.map((importer) =>
+//         getModuleFilePathAbsolute(importer, config),
+//       );
+//       errMsg += ` by ${joinEnglish(importPaths, "and")}`;
+//     }
+
+//     if (onlyWarn) {
+//       errMsg +=
+//         " and, therefore, reveal will prevent building your app for production.";
+//     }
+
+//     return errMsg;
+//   }
+
+//   function isWrongEnv(moduleId: string, isServerSide: boolean): boolean {
+//     const modulePath = getModulePath(moduleId);
+//     const suffixWrong = getSuffix(isServerSide ? "client" : "server");
+//     return modulePath.includes(suffixWrong);
+//   }
+
+//   function skip(id: string): boolean {
+//     // TODO/v1-release: remove
+//     if (extractAssetsRE.test(id) || extractExportNamesRE.test(id)) return true;
+//     if (!id.includes(getSuffix("client")) && !id.includes(getSuffix("server")))
+//       return true;
+//     if (getModulePath(id).endsWith(".css")) return true;
+//     // Apply `.server.js` and `.client.js` only to user files
+//     if (id.includes("/node_modules/")) return true;
+//     // Only user files
+//     if (!id.startsWith(config.root)) return true;
+//     return false;
+//   }
+
+//   function getSuffix(env: "client" | "server") {
+//     return `.${env}.` as const;
+//   }
+
+//   function getModulePath(moduleId: string) {
+//     return moduleId.split("?")[0]!;
+//   }
+// }

package/dist/plugins/importBuild/getRevealManifest.ts

@@ -0,0 +1,20 @@
+export { getRevealManifest };
+
+import {
+  assertPluginManifest,
+  PluginManifest,
+} from "../../core/gaurds/assertions/assertPluginManifest.js";
+import { getRuntimeManifest } from "../../core/globals/contexts/globalContext/index.js";
+import { ConfigRevealResolved } from "../../types/interfaces/reveal.js";
+
+import { projectInfo } from "../utils.js";
+
+function getRevealManifest(configReveal: ConfigRevealResolved): PluginManifest {
+  const runtimeManifest = getRuntimeManifest(configReveal);
+  const manifest = {
+    version: projectInfo.projectVersion,
+    ...runtimeManifest,
+  };
+  assertPluginManifest(manifest);
+  return manifest;
+}

package/dist/plugins/importBuild/index.ts

@@ -0,0 +1,120 @@
+export { importBuild, set_ASSETS_MAP }
+
+// @ts-ignore - Type declarations may not be available for this package
+import { serverEntryPlugin } from "@brillout/vite-plugin-server-entry/plugin"
+import fs from "fs/promises"
+import { createRequire } from "module"
+import path from "path"
+import type { Plugin, ResolvedConfig, Rollup } from "vite"
+import { virtualFileIdImportUserCodeServer } from "../../core/files/virtual-files/virtualFileImportUserCode.js"
+import { getConfigReveal } from "../../core/processing/getters/getConfigReveal.js"
+import { ConfigRevealResolved } from "../../types/interfaces/reveal.js"
+import { assert, getOutDirs, toPosixPath } from "../utils.js"
+import { getRevealManifest } from "./getRevealManifest.js"
+
+const importMetaUrl: string = import.meta.url
+const require_ = createRequire(importMetaUrl)
+type Bundle = Rollup.OutputBundle
+type Options = Rollup.NormalizedOutputOptions
+const ASSETS_MAP = "__VITE_ASSETS_MAP__"
+
+function importBuild(): Plugin[] {
+  let config: ResolvedConfig
+  let configReveal: ConfigRevealResolved
+  return [
+    {
+      name: "reveal:importBuild:config",
+      enforce: "post",
+      async configResolved(config_: ResolvedConfig) {
+        config = config_
+        configReveal = await getConfigReveal(config)
+      },
+    },
+    ...serverEntryPlugin({
+      getImporterCode: () => {
+        return getEntryCode(config, configReveal)
+      },
+      libraryName: "reveal",
+    }),
+  ]
+}
+
+function getEntryCode(
+  config: ResolvedConfig,
+  configReveal: ConfigRevealResolved
+): string {
+  const importPath = getImportPath(config)
+  const revealManifest = getRevealManifest(configReveal)
+  const importerCode = [
+    `  import { setImportBuildGetters } from '${importPath}';`,
+    `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
+    `  {`,
+    // We first set the values to a variable because of a Rollup bug, and this workaround doesn't work: https://github.com/revealjs/reveal/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
+    `    const assetsManifest = ${ASSETS_MAP};`,
+    `    const pluginManifest = ${JSON.stringify(revealManifest, null, 2)};`,
+    "    setImportBuildGetters({",
+    `      pageFiles: () => pageFiles,`,
+    `      getAssetsManifest: () => assetsManifest,`,
+    // TODO: rename pluginManifest -> revealManifest
+    `      pluginManifest: () => pluginManifest,`,
+    "    });",
+    `  }`,
+    "",
+  ].join("\n")
+  return importerCode
+}
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+async function set_ASSETS_MAP(options: Options, bundle: Bundle) {
+  const { dir } = options
+  assert(dir)
+  const chunkPath = find_ASSETS_MAP(bundle)
+  const chunkFilePath = path.join(dir, chunkPath)
+  const assetsJsonFilePath = path.join(dir, "..", "assets.json")
+  const [assetsJsonResult, chunkFileResult] = await Promise.allSettled([
+    await fs.readFile(assetsJsonFilePath, "utf8"),
+    await fs.readFile(chunkFilePath, "utf8"),
+  ])
+  if (
+    assetsJsonResult.status === "rejected" ||
+    chunkFileResult.status === "rejected"
+  ) {
+    throw new Error("Failed to read files")
+  }
+  const serverEntryFileContentPatched = chunkFileResult.value.replace(
+    ASSETS_MAP,
+    assetsJsonResult.value
+  )
+  assert(serverEntryFileContentPatched !== chunkFileResult.value)
+  await fs.writeFile(chunkFilePath, serverEntryFileContentPatched)
+}
+function find_ASSETS_MAP(bundle: Bundle): string {
+  let chunkPath: string | undefined
+  for (const filePath in bundle) {
+    const chunk = bundle[filePath]!
+    if ("code" in chunk && chunk.code.includes(ASSETS_MAP)) {
+      assert(!chunkPath)
+      chunkPath = filePath
+    }
+  }
+  assert(chunkPath)
+  return chunkPath
+}
+function getImportPath(config: ResolvedConfig) {
+  // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
+  const filePathAbsolute = toPosixPath(
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/reveal/dist/node/plugin/plugins/importBuild/index.js
+    require_.resolve(
+      `../../../../../../dist/node/runtime/globalContext/loadImportBuild.js`
+    )
+  )
+  if (
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'reveal/__internal/loadImportBuild' (AFAIK a relative path is needed only if a framework has npm package 'reveal' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    true as boolean
+  ) {
+    return "reveal/__internal/loadImportBuild"
+  } else {
+    const { outDirServer } = getOutDirs(config)
+    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute)
+    return filePathRelative
+  }
+}

package/dist/plugins/importUserCode/addImportStatement.ts

@@ -0,0 +1,32 @@
+export { addImportStatement };
+
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ */
+function addImportStatement(
+  importStatements: string[],
+  importPath: string,
+  exportName: string,
+): { importName: string } {
+  const importCounter = importStatements.length + 1;
+  const importName = `import${importCounter}` as const;
+  const importLiteral = (() => {
+    if (exportName === "*") {
+      return `* as ${importName}` as const;
+    }
+    if (exportName === "default") {
+      return importName;
+    }
+    return `{ ${exportName} as ${importName} }` as const;
+  })();
+  const importStatement = `import ${importLiteral} from '${importPath}';`;
+  importStatements.push(importStatement);
+  return { importName };
+}

package/dist/plugins/importUserCode/debug.ts

@@ -0,0 +1,2 @@
+import { createDebugger } from "../utils.js";
+export const debug = createDebugger("reveal:virtual-files");

package/dist/plugins/importUserCode/getConfigFileExport.ts

@@ -0,0 +1,24 @@
+export { getConfigFileExport };
+
+import pc from "@brillout/picocolors";
+import { assertUsage, isObject } from "../utils.js";
+import { assertPlusFileExport } from "../../core/gaurds/assertions/assertPlusFileExport.js";
+
+function getConfigFileExport(
+  fileExports: Record<string, unknown>,
+  filePathToShowToUser: string,
+): Record<string, unknown> {
+  assertPlusFileExport(fileExports, filePathToShowToUser, "config");
+  const usesNamedExport = !!fileExports.config;
+  const fileExport = usesNamedExport ? fileExports.config : fileExports.default;
+  const exportName = pc.cyan(
+    usesNamedExport ? "export { config }" : "export default",
+  );
+  assertUsage(
+    isObject(fileExport),
+    `The ${exportName} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(
+      `typeof exportedValue === ${JSON.stringify(typeof fileExport)}`,
+    )} instead)`,
+  );
+  return fileExport;
+}

package/dist/plugins/importUserCode/getVirtualFilePageConfigValuesAll.ts

@@ -0,0 +1,95 @@
+export { getVirtualFilePageConfigValuesAll }
+
+import type { ResolvedConfig } from "vite"
+import { extractAssetsAddQuery } from "../../core/assets/extractAssetsQuery.js"
+import {
+  getVirtualFileIdPageConfigValuesAll,
+  isVirtualFileIdPageConfigValuesAll,
+} from "../../core/files/virtual-files/virtualFilePageConfigValuesAll.js"
+import { getConfigReveal } from "../../core/processing/getters/getConfigReveal.js"
+import { getConfigValueBuildTime } from "../../core/processing/getters/getConfigValueBuildTime.js"
+import { getRevealConfig } from "../../core/processing/getters/getRevealConfig/index.js"
+import { serializeConfigValues } from "../../core/processing/serializers/serializePage/serializeConfigValues.js"
+import { PageConfigBuildTime } from "../../types/interfaces/page.js"
+import { fixServerAssets_isEnabled } from "../config/fixServerAssets.js"
+import { assert } from "../utils.js"
+import { debug } from "./debug.js"
+import { isRuntimeEnvMatch } from "./isRuntimeEnvMatch.js"
+
+async function getVirtualFilePageConfigValuesAll(
+  id: string,
+  isDev: boolean,
+  config: ResolvedConfig
+): Promise<string> {
+  const result = isVirtualFileIdPageConfigValuesAll(id)
+  assert(result)
+  /* This assertion fails when using includeAssetsImportedByServer
+  {
+    const isForClientSide = !config.build.ssr
+    assert(result.isForClientSide === isForClientSide)
+  }
+  */
+  const { pageId, isForClientSide } = result
+  const { pageConfigs } = await getRevealConfig(config, isDev, {
+    tolerateInvalidConfig: true,
+  })
+  const pageConfig = pageConfigs.find(
+    (pageConfig) => pageConfig.pageId === pageId
+  )
+  assert(pageConfig)
+  const configreveal = await getConfigReveal(config)
+  const code = getLoadConfigValuesAll(
+    pageConfig,
+    isForClientSide,
+    pageId,
+    configreveal.includeAssetsImportedByServer,
+    isDev
+  )
+  debug(id, isForClientSide ? "CLIENT-SIDE" : "SERVER-SIDE", code)
+  return code
+}
+
+function getLoadConfigValuesAll(
+  pageConfig: PageConfigBuildTime,
+  isForClientSide: boolean,
+  pageId: string,
+  includeAssetsImportedByServer: boolean,
+  isDev: boolean
+): string {
+  const lines: string[] = []
+  const importStatements: string[] = []
+  const isClientRouting =
+    getConfigValueBuildTime(pageConfig, "clientRouting", "boolean")?.value ??
+    false
+
+  lines.push("export const configValuesSerialized = {")
+  lines.push(
+    ...serializeConfigValues(
+      pageConfig,
+      importStatements,
+      (configEnv) =>
+        isRuntimeEnvMatch(configEnv, {
+          isForClientSide,
+          isClientRouting,
+          isDev,
+        }),
+      { isEager: false },
+      ""
+    )
+  )
+  lines.push("};")
+
+  if (
+    !fixServerAssets_isEnabled() &&
+    includeAssetsImportedByServer &&
+    isForClientSide &&
+    !isDev
+  ) {
+    importStatements.push(
+      `import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`
+    )
+  }
+
+  const code = [...importStatements, ...lines].join("\n")
+  return code
+}