@revealui/core 0.0.1-pre.0

package/dist/plugins/importUserCode/getVirtualFilePageConfigs.ts

@@ -0,0 +1,150 @@
+export { getVirtualFilePageConfigs };
+
+import type { ResolvedConfig } from "vite";
+import { getRevealConfig } from "../../core/processing/getters/getRevealConfig/index.js";
+import { serializeConfigValues } from "../../core/processing/serializers/serializePage/serializeConfigValues.js";
+
+import {
+  PageConfigBuildTime,
+  PageConfigGlobalBuildTime,
+} from "../../types/interfaces/page.js";
+import { debug } from "./debug.js";
+import { isRuntimeEnvMatch } from "./isRuntimeEnvMatch.js";
+import { getVirtualFileIdPageConfigValuesAll } from "../../core/files/virtual-files/virtualFilePageConfigValuesAll.js";
+
+async function getVirtualFilePageConfigs(
+  isForClientSide: boolean,
+  isDev: boolean,
+  id: string,
+  isClientRouting: boolean,
+  config: ResolvedConfig,
+): Promise<string> {
+  const { pageConfigs, pageConfigGlobal } = await getRevealConfig(
+    config,
+    isDev,
+    {
+      tolerateInvalidConfig: true,
+    },
+  );
+  return getCode(
+    pageConfigs,
+    pageConfigGlobal,
+    isForClientSide,
+    isDev,
+    id,
+    isClientRouting,
+  );
+}
+
+function getCode(
+  pageConfigs: PageConfigBuildTime[],
+  pageConfigGlobal: PageConfigGlobalBuildTime,
+  isForClientSide: boolean,
+  isDev: boolean,
+  id: string,
+  isClientRouting: boolean,
+): string {
+  const lines: string[] = [];
+  const importStatements: string[] = [];
+
+  lines.push("export const pageConfigsSerialized = [");
+  lines.push(
+    getCodePageConfigsSerialized(
+      pageConfigs,
+      isForClientSide,
+      isClientRouting,
+      isDev,
+      importStatements,
+    ),
+  );
+  lines.push("];");
+
+  lines.push("export const pageConfigGlobalSerialized = {");
+  lines.push(
+    getCodePageConfigGlobalSerialized(
+      pageConfigGlobal,
+      isForClientSide,
+      isClientRouting,
+      isDev,
+      importStatements,
+    ),
+  );
+  lines.push("};");
+
+  const code = [...importStatements, ...lines].join("\n");
+  debug(id, isForClientSide ? "CLIENT-SIDE" : "SERVER-SIDE", code);
+  return code;
+}
+
+function getCodePageConfigsSerialized(
+  pageConfigs: PageConfigBuildTime[],
+  isForClientSide: boolean,
+  isClientRouting: boolean,
+  isDev: boolean,
+  importStatements: string[],
+): string {
+  const lines: string[] = [];
+
+  pageConfigs.forEach((pageConfig) => {
+    const { pageId, routeFilesystem, isErrorPage } = pageConfig;
+    const virtualFileIdPageConfigValuesAll =
+      getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
+    lines.push(`  {`);
+    lines.push(`    pageId: ${JSON.stringify(pageId)},`);
+    lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
+    lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
+    lines.push(
+      `    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`,
+    );
+    lines.push(`    configValuesSerialized: {`);
+    lines.push(
+      ...serializeConfigValues(
+        pageConfig,
+        importStatements,
+        (configEnv) =>
+          isRuntimeEnvMatch(configEnv, {
+            isForClientSide,
+            isClientRouting,
+            isDev,
+          }),
+        { isEager: true },
+        "    ",
+      ),
+    );
+    lines.push(`    },`);
+    lines.push(`  },`);
+  });
+
+  const code = lines.join("\n");
+  return code;
+}
+
+function getCodePageConfigGlobalSerialized(
+  pageConfigGlobal: PageConfigGlobalBuildTime,
+  isForClientSide: boolean,
+  isClientRouting: boolean,
+  isDev: boolean,
+  importStatements: string[],
+) {
+  const lines: string[] = [];
+
+  lines.push(`  configValuesSerialized: {`);
+  lines.push(
+    ...serializeConfigValues(
+      pageConfigGlobal,
+      importStatements,
+      (configEnv) =>
+        isRuntimeEnvMatch(configEnv, {
+          isForClientSide,
+          isClientRouting,
+          isDev,
+        }),
+      { isEager: true },
+      "    ",
+    ),
+  );
+  lines.push(`  },`);
+
+  const code = lines.join("\n");
+  return code;
+}

package/dist/plugins/importUserCode/index.ts

@@ -0,0 +1,375 @@
+import pc from "@brillout/picocolors"
+import type {
+  ConfigEnv,
+  HmrContext,
+  ModuleNode,
+  Plugin,
+  ResolvedConfig,
+  ViteDevServer,
+} from "vite"
+import { normalizePath } from "vite"
+
+import {
+  assertPosixPath,
+  getOutDirs,
+  getVirtualFileId,
+  isDev3,
+  isVirtualFileId,
+  resolveVirtualFileId,
+} from "../utils.js"
+
+import { assert } from "../../core/gaurds/assertions/assert/index.js"
+import { getConfigReveal } from "../../core/processing/getters/getConfigReveal.js"
+import { getModuleFilePathAbsolute } from "../../core/processing/getters/getFilePath.js"
+import {
+  isRevealConfigFile,
+  reloadRevealConfig,
+  revealConfigDependencies,
+} from "../../core/processing/getters/getRevealConfig/index.js"
+
+import { isVirtualFileIdImportUserCode } from "../../core/files/virtual-files/virtualFileImportUserCode.js"
+import { isVirtualFileIdPageConfigValuesAll } from "../../core/files/virtual-files/virtualFilePageConfigValuesAll.js"
+import { logConfigInfo } from "../../core/gaurds/logger/loggerNotProd.js"
+import { ConfigRevealResolved } from "../../types/interfaces/reveal.js"
+import { getVirtualFilePageConfigValuesAll } from "./getVirtualFilePageConfigValuesAll.js"
+
+type PluginImportUserCode = Plugin & {
+  name: string
+  config: (config: any, env: any) => any
+  configResolved: (config: any) => void
+  resolveId: (id: string) => string | undefined
+  handleHotUpdate: (ctx: HmrContext) => ModuleNode[] | undefined
+  load: (id: string, options: any) => Promise<string | undefined>
+  configureServer: (server: ViteDevServer) => void
+}
+
+// Main plugin function
+function importUserCode(): PluginImportUserCode {
+  let config: ResolvedConfig
+  let configReveal: ConfigRevealResolved
+  let isDev: boolean | undefined
+
+  return {
+    name: "reveal:importUserCode",
+
+    config(
+      config_: ResolvedConfig,
+      env: ConfigEnv
+    ): {
+      experimental: {
+        importGlobRestoreExtension: boolean
+      }
+    } {
+      isDev = isDev3(env)
+      return {
+        experimental: {
+          importGlobRestoreExtension: true, // Future removal planned
+        },
+      }
+    },
+
+    // Resolve configuration
+    async configResolved(config_: ResolvedConfig) {
+      configReveal = await getConfigReveal(config_)
+      config = config_
+    },
+
+    // Resolve virtual file IDs
+    resolveId(id: string): string | undefined {
+      if (isVirtualFileId(id)) {
+        return resolveVirtualFileId(id)
+      }
+    },
+
+    // Handle hot updates
+    handleHotUpdate(ctx: HmrContext) {
+      try {
+        return handleHotUpdate(ctx, config)
+      } catch (err) {
+        // Log errors during hot update
+        console.error(err)
+        throw err
+      }
+    },
+
+    // Load virtual file content
+    async load(id: string, options: any) {
+      if (!isVirtualFileId(id)) return undefined
+      id = getVirtualFileId(id)
+      assert(typeof isDev === "boolean")
+
+      if (isVirtualFileIdPageConfigValuesAll(id)) {
+        const code = await getVirtualFilePageConfigValuesAll(id, isDev, config)
+        return code
+      }
+    },
+
+    // Configure server for file add/remove events
+    configureServer(server: ViteDevServer) {
+      handleFileAddRemove(server, config)
+    },
+  }
+}
+
+// Handle file additions and removals
+function handleFileAddRemove(server: ViteDevServer, config: ResolvedConfig) {
+  server.watcher.prependListener("add", (f: string) => listener(f, false))
+  server.watcher.prependListener("unlink", (f: string) => listener(f, true))
+
+  function listener(file: string, isRemove: boolean) {
+    file = normalizePath(file)
+    const isRevealConfig =
+      isRevealConfigModule(file) || isRevealConfigFile(file)
+
+    if (isRevealConfig) {
+      const virtualModules = getVirtualModules(server)
+      virtualModules.forEach((mod) => {
+        server.moduleGraph.invalidateModule(mod) // Invalidate modules related to the config
+      })
+      reloadConfig(file, config, isRemove ? "removed" : "created")
+    }
+  }
+}
+
+// Handle hot updates for HMR
+function handleHotUpdate(ctx: HmrContext, config: ResolvedConfig) {
+  const { file, server } = ctx
+  assertPosixPath(file)
+  revealConfigDependencies.forEach((f) => assertPosixPath(f))
+  const isRevealConfig = isRevealConfigModule(file)
+
+  const isViteModule = ctx.modules.length > 0
+
+  // If not a reveal config and no Vite module, skip further processing
+  if (!isRevealConfig && !isViteModule) {
+    // Optional: Log message for non-HMR files
+    return
+  }
+
+  if (isRevealConfig) {
+    reloadConfig(file, config, "modified")
+    const virtualModules = getVirtualModules(server)
+    return virtualModules // Return updated virtual modules
+  }
+}
+
+// Check if the file is a reveal config module
+function isRevealConfigModule(filePathAbsoluteFilesystem: string): boolean {
+  return revealConfigDependencies.has(filePathAbsoluteFilesystem)
+}
+
+// Reload configuration on file modification
+function reloadConfig(
+  filePath: string,
+  config: ResolvedConfig,
+  op: "modified" | "created" | "removed"
+) {
+  const filePathToShowToUserResolved = getModuleFilePathAbsolute(
+    filePath,
+    config
+  )
+  const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`
+  logConfigInfo(msg, "info")
+  reloadRevealConfig(config.root, getOutDirs(config).outDirRoot)
+}
+
+// Get virtual modules for the current server
+function getVirtualModules(server: ViteDevServer): ModuleNode[] {
+  const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+    .filter(
+      (url) =>
+        isVirtualFileIdPageConfigValuesAll(url) ||
+        isVirtualFileIdImportUserCode(url)
+    )
+    .map((url) => {
+      const mod = server.moduleGraph.urlToModuleMap.get(url)
+      assert(mod)
+      return mod
+    })
+  return virtualModules
+}
+
+export { importUserCode }
+
+// export { importUserCode }
+
+// import pc from "@brillout/picocolors"
+// import type {
+//   HmrContext,
+//   ModuleNode,
+//   Plugin,
+//   ResolvedConfig,
+//   ViteDevServer,
+// } from "vite"
+// import { normalizePath } from "vite"
+// import type { ConfigRevealResolved } from "../../../ConfigReveal.js"
+// import { getConfigReveal } from "../../getConfigReveal.js"
+// import { isVirtualFileIdImportUserCode } from "../../virtual-files/virtualFileImportUserCode.js"
+// import { isVirtualFileIdPageConfigValuesAll } from "../../virtual-files/virtualFilePageConfigValuesAll.js"
+// import { getModuleFilePathAbsolute } from "../getFilePath.js"
+// import { logConfigInfo } from "../loggerNotProd.js"
+// import {
+//   assert,
+//   assertPosixPath,
+//   getOutDirs,
+//   getVirtualFileId,
+//   isDev3,
+//   isVirtualFileId,
+//   resolveVirtualFileId,
+// } from "../../utils.js"
+
+// import {
+//   isRevealConfigFile,
+//   reloadRevealConfig,
+//   revealConfigDependencies,
+// } from "./v1-design/getRevealConfig.js"
+// import { getVirtualFilePageConfigValuesAll } from "./v1-design/getVirtualFilePageConfigValuesAll.js"
+
+// function importUserCode(): Plugin {
+//   let config: ResolvedConfig
+//   let configReveal: ConfigRevealResolved
+//   let isDev: boolean | undefined
+//   return {
+//     name: "reveal:importUserCode",
+//     config(_, env) {
+//       isDev = isDev3(env)
+//       return {
+//         experimental: {
+//           // TODO/v1-release: remove
+//           importGlobRestoreExtension: true,
+//         },
+//       }
+//     },
+//     async configResolved(config_) {
+//       configReveal = await getConfigReveal(config_)
+//       config = config_
+//     },
+//     resolveId(id) {
+//       if (isVirtualFileId(id)) {
+//         return resolveVirtualFileId(id)
+//       }
+//     },
+//     handleHotUpdate(ctx) {
+//       try {
+//         return handleHotUpdate(ctx, config)
+//       } catch (err) {
+//         // Vite swallows errors thrown by handleHotUpdate()
+//         console.error(err)
+//         throw err
+//       }
+//     },
+//     async load(id, options) {
+//       if (!isVirtualFileId(id)) return undefined
+//       id = getVirtualFileId(id)
+//       assert(typeof isDev === "boolean")
+
+//       if (isVirtualFileIdPageConfigValuesAll(id)) {
+//         const code = await getVirtualFilePageConfigValuesAll(id, isDev, config)
+//         return code
+//       }
+
+//       if (isVirtualFileIdImportUserCode(id)) {
+//         const code = await getVirtualFileImportUserCode(
+//           id,
+//           options,
+//           configReveal,
+//           config,
+//           isDev
+//         )
+//         return code
+//       }
+//     },
+//     configureServer(server) {
+//       handleFileAddRemove(server, config)
+//     },
+//   }
+// }
+
+// function handleFileAddRemove(server: ViteDevServer, config: ResolvedConfig) {
+//   server.watcher.prependListener("add", (f) => listener(f, false))
+//   server.watcher.prependListener("unlink", (f) => listener(f, true))
+//   return
+//   function listener(file: string, isRemove: boolean) {
+//     file = normalizePath(file)
+//     const isRevealConfig = isRevealConfigModule(file) || isRevealConfigFile(file)
+//     if (isRevealConfig) {
+//       const virtualModules = getVirtualModules(server)
+//       virtualModules.forEach((mod) => {
+//         server.moduleGraph.invalidateModule(mod)
+//       })
+//       reloadConfig(file, config, isRemove ? "removed" : "created")
+//     }
+//   }
+// }
+
+// function handleHotUpdate(ctx: HmrContext, config: ResolvedConfig) {
+//   const { file, server } = ctx
+//   assertPosixPath(file)
+//   revealConfigDependencies.forEach((f) => assertPosixPath(f))
+//   const isRevealConfig = isRevealConfigModule(file)
+
+//   const isViteModule = ctx.modules.length > 0
+
+//   /* Should we show this?
+//   // - Can be useful for server files that aren't processed by Vite.
+//   // - Can be annoying for files that obviously aren't processed by Vite.
+//   if (!isRevealConfig && !isViteModule) {
+//     logViteAny(
+//       `${msg} — ${pc.cyan('no HMR')}, see https://reveal.dev/on-demand-compiler`,
+//       'info',
+//       null,
+//       true
+//     )
+//     return
+//   }
+//   //*/
+
+//   // It can hide an error it shouldn't hide (because the error isn't shown again), but it's ok since users can reload the page and the error will be shown again (Vite transpilation errors are shown again upon a page reload).
+//   if (!isRevealConfig && isViteModule) {
+//     return
+//   }
+
+//   if (isRevealConfig) {
+//     /* Tailwind breaks this assertion, see https://github.com/revealjs/reveal/discussions/1330#discussioncomment-7787238
+//     assert(!isViteModule)
+//     */
+//     reloadConfig(file, config, "modified")
+//     const virtualModules = getVirtualModules(server)
+//     return virtualModules
+//   }
+// }
+
+// function isRevealConfigModule(filePathAbsoluteFilesystem: string): boolean {
+//   return revealConfigDependencies.has(filePathAbsoluteFilesystem)
+// }
+
+// function reloadConfig(
+//   filePath: string,
+//   config: ResolvedConfig,
+//   op: "modified" | "created" | "removed"
+// ) {
+//   {
+//     const filePathToShowToUserResolved = getModuleFilePathAbsolute(
+//       filePath,
+//       config
+//     )
+//     const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`
+//     logConfigInfo(msg, "info")
+//   }
+//   reloadRevealConfig(config.root, getOutDirs(config).outDirRoot)
+// }
+
+// function getVirtualModules(server: ViteDevServer): ModuleNode[] {
+//   const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+//     .filter(
+//       (url) =>
+//         isVirtualFileIdPageConfigValuesAll(url) ||
+//         isVirtualFileIdImportUserCode(url)
+//     )
+//     .map((url) => {
+//       const mod = server.moduleGraph.urlToModuleMap.get(url)
+//       assert(mod)
+//       return mod
+//     })
+//   return virtualModules
+// }

package/dist/plugins/importUserCode/isRuntimeEnvMatch.ts

@@ -0,0 +1,31 @@
+import { ConfigEnvInternal } from "../../types/interfaces/page";
+
+export { isRuntimeEnvMatch };
+
+function isRuntimeEnvMatch(
+  configEnv: ConfigEnvInternal,
+  runtime: {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+    isDev: boolean;
+  },
+): boolean {
+  // Runtime
+  if (!runtime.isForClientSide) {
+    if (!configEnv.server) return false;
+  } else {
+    if (!configEnv.client) return false;
+    if (configEnv.client === "if-client-routing" && !runtime.isClientRouting)
+      return false;
+  }
+
+  // Production/development
+  if (
+    //
+    (configEnv.production === true && runtime.isDev) ||
+    (configEnv.production === false && !runtime.isDev)
+  )
+    return false;
+
+  return true;
+}