@revealui/core 0.0.1-pre.0

package/dist/plugins/index.ts

@@ -0,0 +1,233 @@
+export default plugin;
+export { plugin, plugin as ssr };
+export type { ConfigRevealUserProvided as UserConfig };
+
+import pc from "@brillout/picocolors";
+import { version } from "vite";
+import { loadRevealConfig } from "../config/index.js";
+import { assertUsage } from "../core/gaurds/assertions/assertUsage/index.js";
+import { setResolveClientEntriesDev } from "../core/processing/getters/getPageAssets.js";
+import { pluginRegistry } from "../plugin/registry.js";
+import type { ConfigRevealUserProvided } from "../types/interfaces/reveal.js";
+import { baseUrls } from "./baseUrls.js";
+import { buildConfig } from "./buildConfig/index.js";
+import { commonConfig } from "./commonConfig.js";
+import { resolveRevealConfig } from "./config/index.js";
+import { devConfig } from "./devConfig/index.js";
+import { distFileNames } from "./distFileNames.js";
+import { envVarsPlugin } from "./envVars.js";
+import { extractAssetsPlugin } from "./extractAssetsPlugin.js";
+import { extractExportNamesPlugin } from "./extractExportNamesPlugin.js";
+import { fileEnv } from "./fileEnv.js";
+import { importBuild } from "./importBuild/index.js";
+import { importUserCode } from "./importUserCode/index.js";
+import { packageJsonFile } from "./packageJsonFile.js";
+import { previewConfig } from "./previewConfig.js";
+import { removeRequireHookPlugin } from "./removeRequireHookPlugin.js";
+import { resolveClientEntriesDev } from "./resolveClientEntriesDev.js";
+import { setGlobalContext } from "./setGlobalContext.js";
+import { suppressRollupWarning } from "./suppressRollupWarning.js";
+import {
+	assertNodeEnv_onRevealPluginLoad,
+	assertVersion,
+	markEnvAsRevealPluginLoaded,
+} from "./utils.js";
+import { workaroundCssModuleHmr } from "./workaroundCssModuleHmr.js";
+
+assertNodeEnv_onRevealPluginLoad();
+markEnvAsRevealPluginLoaded();
+assertViteVersion();
+setResolveClientEntriesDev(resolveClientEntriesDev);
+
+// Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
+function plugin(revealConfig?: ConfigRevealUserProvided): any {
+	// Register plugins from passed config if provided
+	// Note: plugins are part of RevealUserConfig, not RevealConfig
+	if (
+		revealConfig &&
+		typeof revealConfig === "object" &&
+		"plugins" in revealConfig
+	) {
+		const plugins = (revealConfig as { plugins?: unknown }).plugins;
+		if (Array.isArray(plugins)) {
+			for (const pluginDef of plugins) {
+				pluginRegistry.register(pluginDef);
+			}
+		}
+	}
+
+	// Get registered RevealUI plugins and convert them to Vite plugins
+	// RevealUI plugins extend Vite's Plugin interface, so they can be used directly
+	// We'll wrap them to ensure proper lifecycle hook execution
+	const revealPlugins = pluginRegistry.getPlugins();
+	const vitePluginsFromReveal = revealPlugins.map((plugin) => {
+		// Create a Vite plugin wrapper that ensures lifecycle hooks are called
+		const vitePlugin = {
+			name: (plugin as any).name || "reveal-plugin",
+			enforce: plugin.enforce,
+			apply: plugin.apply,
+			// Map Vite hooks
+			config: plugin.config,
+			configResolved: async (config: import("vite").ResolvedConfig) => {
+				// Call original configResolved if it exists
+				if (plugin.configResolved) {
+					await plugin.configResolved(config);
+				}
+				// Call RevealUI-specific hooks
+				const context = pluginRegistry["context"] as any;
+				if (context?.revealConfig) {
+					const revealContext = {
+						viteConfig: config,
+						revealConfig: context.revealConfig,
+						options: {},
+					};
+					if (plugin.revealConfigResolved) {
+						await plugin.revealConfigResolved(revealContext);
+					}
+				}
+			},
+			...("buildStart" in plugin && (plugin as any).buildStart
+				? { buildStart: (plugin as any).buildStart }
+				: {}),
+			...("buildEnd" in plugin && (plugin as any).buildEnd
+				? { buildEnd: (plugin as any).buildEnd }
+				: {}),
+			transform: plugin.transform,
+			transformIndexHtml: plugin.transformIndexHtml,
+			handleHotUpdate: plugin.handleHotUpdate,
+			resolveId: plugin.resolveId,
+			load: plugin.load,
+			// Include any other Vite plugin properties
+			...Object.fromEntries(
+				Object.entries(plugin).filter(
+					([key]) =>
+						![
+							"name",
+							"revealConfigResolved",
+							"revealPluginInit",
+							"revealReady",
+							"revealConfig",
+						].includes(key),
+				),
+			),
+		};
+		return vitePlugin;
+	});
+
+	const plugins = [
+		resolveRevealConfig(revealConfig), // The configResolved() hook of resolveRevealConfig() should be the first called
+		...commonConfig(),
+		importUserCode(),
+		...devConfig(),
+		...buildConfig(),
+		previewConfig(),
+		packageJsonFile(),
+		removeRequireHookPlugin(),
+		distFileNames(),
+		...extractAssetsPlugin(),
+		extractExportNamesPlugin(),
+		suppressRollupWarning(),
+		setGlobalContext(),
+		...importBuild(),
+		baseUrls(revealConfig),
+		envVarsPlugin(),
+		fileEnv(),
+		workaroundCssModuleHmr(),
+		// Add RevealUI plugins as Vite plugins
+		...vitePluginsFromReveal,
+		// Plugin registry integration - handles config resolution and lifecycle
+		{
+			name: "reveal:plugin-registry",
+			enforce: "pre",
+			async configResolved(config: import("vite").ResolvedConfig) {
+				let finalRevealConfig: ConfigRevealUserProvided;
+
+				// Try to load reveal.config.ts if not provided
+				if (!revealConfig) {
+					try {
+						const loadedConfig = await loadRevealConfig();
+						finalRevealConfig = loadedConfig as ConfigRevealUserProvided;
+						// Register plugins from reveal.config.ts if they exist
+						if (
+							loadedConfig &&
+							typeof loadedConfig === "object" &&
+							"plugins" in loadedConfig
+						) {
+							const configPlugins = (loadedConfig as { plugins?: unknown })
+								.plugins;
+							if (Array.isArray(configPlugins)) {
+								for (const pluginDef of configPlugins) {
+									pluginRegistry.register(pluginDef);
+								}
+								// Re-get plugins after registration
+								const newPlugins = pluginRegistry.getPlugins();
+								// Note: Vite doesn't allow adding plugins after config is resolved
+								// Plugins registered here will be available on next build/dev cycle
+							}
+						}
+					} catch {
+						// Config file doesn't exist, continue with defaults
+						finalRevealConfig = {} as ConfigRevealUserProvided;
+					}
+				} else {
+					finalRevealConfig = revealConfig;
+				}
+
+				// Set context for plugins
+				pluginRegistry.setContext({
+					viteConfig: config,
+					revealConfig: finalRevealConfig,
+				});
+
+				// Initialize plugins and call lifecycle hooks
+				const context = {
+					viteConfig: config,
+					revealConfig: finalRevealConfig,
+					options: {},
+				};
+
+				// Call revealConfigResolved on all registered plugins
+				await pluginRegistry.onConfigResolved(context);
+			},
+			async buildStart() {
+				// Call revealReady on all plugins when build starts
+				const context = pluginRegistry["context"] as any;
+				if (context?.viteConfig && context?.revealConfig) {
+					await pluginRegistry.onReady({
+						viteConfig: context.viteConfig,
+						revealConfig: context.revealConfig,
+						options: {},
+					});
+				}
+			},
+		},
+	];
+
+	return plugins;
+}
+
+// Enable `const reveal = require('reveal/plugin')`.
+//  - This lives at the end of the file to ensure it happens after all assignments to `exports`.
+//  - This is only used for the CJS build; we wrap it in a try-catch for the ESM build.
+try {
+	// ESM doesn't need this CJS compatibility layer
+} catch {}
+
+// Error upon wrong usage
+Object.defineProperty(plugin, "apply", {
+	enumerable: true,
+	get: () => {
+		assertUsage(
+			false,
+			`Add ${pc.cyan("reveal()")} instead of ${pc.cyan(
+				"reveal",
+			)} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`,
+			{ showStackTrace: true },
+		);
+	},
+});
+
+// package.json#peerDependencies isn't enough as users can ignore it
+function assertViteVersion() {
+	assertVersion("Vite", version, "5.4.9");
+}

package/dist/plugins/onLoad.ts

@@ -0,0 +1,12 @@
+import { assertIsNotBrowser } from "../core/gaurds/assertions/assertIsNotBrowser";
+import { assertNodeVersion } from "../core/gaurds/assertions/assertNodeVersion";
+import { assertIsNotProductionRuntime } from "./utils";
+
+export { onLoad };
+
+function onLoad() {
+  assertIsNotBrowser();
+  assertNodeVersion();
+  // Ensure we don't bloat the server runtime with heavy plugin dependencies such as esbuild
+  assertIsNotProductionRuntime();
+}

package/dist/plugins/packageJsonFile.ts

@@ -0,0 +1,62 @@
+/*
+ * We create a file `dist/server/package.json` to support ESM users.
+ * Otherwise, following error is thrown:
+ *   Must use import to load ES Module: dist/server/pageFiles.js
+ *   require() of ES modules is not supported.
+ *   require() of dist/server/pageFiles.js from node_modules/reveal/dist/node/runtime/setup.js is an ES module file as it is a .js file whose nearest parent package.json contains "type": "module" which defines all .js files in that package scope as ES modules.
+ * Reproduction: https://github.com/brillout/vite-plugin-ssr-server-import-syntax
+ */
+
+export { packageJsonFile }
+
+import type { Plugin, ResolvedConfig } from "vite"
+
+import { rollupIsEsm } from "../core/gaurds/validators/rollupIsEsm.js"
+import { viteIsSSR } from "./utils.js"
+
+type PluginPackageJsonFile = Plugin & {
+  name: string
+  apply: "build"
+  configResolved(config: ResolvedConfig): void
+  generateBundle(options: any, bundle: Record<string, any>): void
+}
+
+function packageJsonFile(): PluginPackageJsonFile {
+  let config: ResolvedConfig
+  return {
+    name: "reveal:packageJsonFile",
+    apply: "build",
+    configResolved(config_: ResolvedConfig): void {
+      config = config_
+    },
+    generateBundle(
+      this: {
+        emitFile: (options: {
+          fileName: string
+          type: string
+          source: string
+        }) => void
+      },
+      options,
+      bundle
+    ) {
+      if (!viteIsSSR(config)) return
+      const isEsm = rollupIsEsm(options)
+      const fileName = "package.json"
+      if (bundle[fileName]) return
+      this.emitFile({
+        fileName,
+        type: "asset",
+        source: getPackageJsonContent(isEsm),
+      })
+    },
+  }
+}
+
+function getPackageJsonContent(isEsm: boolean): string {
+  if (isEsm) {
+    return `{ "type": "module" }`
+  } else {
+    return `{ "type": "commonjs" }`
+  }
+}

package/dist/plugins/payload/index.ts

@@ -0,0 +1,62 @@
+/**
+ * PayloadCMS plugin for RevealUI
+ * Provides PayloadCMS 3.x integration
+ */
+
+import { createRevealPlugin } from "../../plugin/index.js";
+import type { RevealPlugin } from "../../plugin/index.js";
+
+export interface PayloadPluginOptions {
+  /**
+   * PayloadCMS server URL
+   */
+  serverURL?: string;
+
+  /**
+   * Collections to enable
+   */
+  collections?: string[];
+
+  /**
+   * Globals to enable
+   */
+  globals?: string[];
+
+  /**
+   * Database adapter
+   */
+  database?: "vercel-postgres" | "mongodb" | "postgres";
+
+  /**
+   * Storage adapter
+   */
+  storage?: "vercel-blob" | "local";
+}
+
+/**
+ * PayloadCMS plugin factory
+ */
+export default createRevealPlugin<PayloadPluginOptions>(
+  "reveal:payload",
+  (options = {}) => {
+    const plugin: Omit<RevealPlugin, "name"> = {
+      version: "1.0.0",
+      dependencies: [],
+      revealConfigResolved(context) {
+        // Validate PayloadCMS configuration
+        if (options.serverURL && !options.serverURL.startsWith("http")) {
+          throw new Error(
+            "PayloadCMS serverURL must be a valid HTTP/HTTPS URL"
+          );
+        }
+      },
+      revealReady(context) {
+        // PayloadCMS is typically configured in payload.config.ts
+        // This plugin mainly provides integration hooks
+      },
+    };
+
+    return plugin;
+  }
+);
+

package/dist/plugins/previewConfig.ts

@@ -0,0 +1,95 @@
+export { previewConfig };
+
+import pc from "@brillout/picocolors";
+import fs from "fs";
+import path from "path";
+import type { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+import {
+  assertUsage,
+  getOutDirs,
+  markEnvAsVitePreview,
+  resolveOutDir,
+} from "./utils.js";
+import { ConfigRevealResolved } from "../types/interfaces/reveal.js";
+import { getConfigReveal } from "../core/processing/getters/getConfigReveal.js";
+import { addSsrMiddleware } from "../core/targets/server/middleware/addSsrMiddleware.js";
+
+type ConnectServer = ViteDevServer["middlewares"];
+
+type PluginPreviewConfig = Plugin & {
+  name: string;
+  apply: "serve";
+  config(config: any): any;
+  configResolved(config: ResolvedConfig): void;
+  configurePreviewServer(server: ViteDevServer): () => void;
+};
+
+function previewConfig(): PluginPreviewConfig {
+  let config: ResolvedConfig;
+  let configReveal: ConfigRevealResolved;
+  return {
+    name: "reveal:previewConfig",
+    apply: "serve",
+    config(config: Record<string, any>): {
+      appType: "custom";
+      build: {
+        outDir: string;
+      };
+    } {
+      return {
+        appType: "custom",
+        build: {
+          outDir: resolveOutDir(config),
+        },
+      };
+    },
+    async configResolved(config_: ResolvedConfig): Promise<void> {
+      config = config_;
+      configReveal = await getConfigReveal(config);
+    },
+    configurePreviewServer(server: ViteDevServer): () => void {
+      /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+       - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+      config.appType = 'mpa'
+      */
+      markEnvAsVitePreview();
+      return () => {
+        assertDist();
+
+        /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
+      if (!configReveal.prerender || configReveal.prerender.partial) {
+        addSsrMiddleware(server.middlewares, config, true)
+      }
+      /*/
+        addSsrMiddleware(server.middlewares, config, true);
+        //*/
+
+        addStatic404Middleware(server.middlewares);
+      };
+    },
+  };
+  function assertDist() {
+    let { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
+    [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
+      assertUsage(
+        fs.existsSync(outDirAny),
+        `Cannot run ${pc.cyan("$ vite preview")}: your app isn't built (the build directory ${pc.cyan(
+          outDirAny,
+        )} is missing). Make sure to run ${pc.cyan("$ vite build")} before running ${pc.cyan("$ vite preview")}.`,
+      );
+    });
+  }
+
+  function addStatic404Middleware(middlewares: ConnectServer) {
+    const { outDirClient } = getOutDirs(config);
+    middlewares.use(config.base, (_, res, next) => {
+      const file = path.posix.join(outDirClient, "./404.html");
+      if (fs.existsSync(file)) {
+        res.statusCode = 404;
+        res.end(fs.readFileSync(file));
+      } else {
+        next();
+      }
+    });
+  }
+}

package/dist/plugins/react/index.ts

@@ -0,0 +1,72 @@
+/**
+ * React plugin for RevealUI
+ * Provides React 19 integration with Vike
+ */
+
+import type { Plugin } from "vite";
+import type { RevealPlugin } from "../../plugin/index.js";
+import { createRevealPlugin } from "../../plugin/index.js";
+
+export interface ReactPluginOptions {
+	/**
+	 * Enable React Strict Mode
+	 * @default true
+	 */
+	strictMode?: boolean;
+
+	/**
+	 * Use SWC for faster compilation
+	 * @default true
+	 */
+	useSwc?: boolean;
+}
+
+/**
+ * React plugin factory
+ */
+export default createRevealPlugin<ReactPluginOptions>(
+	"reveal:react",
+	(options = {}) => {
+		const { strictMode = true, useSwc = true } = options;
+
+		const plugin: Omit<RevealPlugin, "name"> = {
+			version: "1.0.0",
+			dependencies: ["vike-react"],
+			revealConfigResolved(context) {
+				// Ensure React 19 is being used
+				const alias = context.viteConfig.resolve?.alias;
+				if (alias && typeof alias === "object" && !Array.isArray(alias)) {
+					const reactAlias = (alias as Record<string, string>)["react"];
+					if (reactAlias && !reactAlias.includes("19")) {
+						console.warn(
+							"RevealUI React plugin expects React 19. Current version may not be compatible.",
+						);
+					}
+				}
+			},
+			// Return as Vite plugin for compatibility
+			config(config: import("vite").UserConfig) {
+				// Add React plugin to Vite config if not already present
+				const plugins = (config.plugins as Plugin[]) || [];
+				const hasReactPlugin = plugins.some((p) => {
+					if (typeof p === "object" && p !== null) {
+						return (p as { name?: string }).name === "vite:react";
+					}
+					if (typeof p === "function") {
+						return (p as { name?: string }).name === "react";
+					}
+					return false;
+				});
+
+				if (!hasReactPlugin) {
+					// React plugin should be added by vike-react
+					// This is just a placeholder
+				}
+
+				return config;
+			},
+		};
+
+		return plugin;
+	},
+);

package/dist/plugins/removeRequireHookPlugin.ts

@@ -0,0 +1,27 @@
+// We remove: https://github.com/vitejs/vite/blob/dd79858ab70d2591e1239ddb19e1ce38d9913b4c/packages/vite/src/node/plugins/ssrRequireHook.ts
+// Because it injects `require('module')` into the build which chokes bundlers, such as Cloudflare Workers's webpack-based bundler.
+// The minimal added value of deduping React is not worth the trouble; we simply remove Vite's deduping functionality for production.
+
+import type { Plugin } from "vite";
+
+export { removeRequireHookPlugin };
+
+type PluginRemoveRequireHook = Plugin & {
+  name: string;
+  apply: "build";
+  configResolved(config: any): void;
+};
+
+function removeRequireHookPlugin(): PluginRemoveRequireHook {
+  return {
+    name: "reveal:removeRequireHookPlugin",
+    apply: "build",
+    configResolved(config: { plugins: Array<{ name: string }> }): void {
+      const pluginsMod = config.plugins.filter(
+        (plugin) => plugin.name !== "vite:ssr-require-hook",
+      );
+      // @ts-ignore
+      config.plugins = pluginsMod;
+    },
+  };
+}

package/dist/plugins/resolveClientEntriesDev.ts

@@ -0,0 +1,87 @@
+export { resolveClientEntriesDev }
+export type ResolveClientEntriesDev = typeof resolveClientEntriesDev
+
+import { createRequire } from "module"
+import { dirname } from "path"
+import { fileURLToPath } from "url"
+import type { ViteDevServer } from "vite"
+import {
+  assert,
+  assertIsNotProductionRuntime,
+  assertIsNpmPackageImport,
+  assertPosixPath,
+  pathShim,
+  toPosixPath,
+} from "./utils.js"
+
+const importMetaUrl: string = import.meta.url
+const require_ = createRequire(importMetaUrl)
+const __dirname_ = dirname(fileURLToPath(importMetaUrl))
+console.log("__dirname_", __dirname_)
+
+assertIsNotProductionRuntime()
+
+async function resolveClientEntriesDev(
+  clientEntry: string,
+  viteDevServer: ViteDevServer
+): Promise<string> {
+  let root = viteDevServer.config.root
+  assert(root)
+  root = toPosixPath(root)
+
+  // The `?import` suffix is needed for MDX to be transpiled:
+  //   - Not transpiled: `/pages/markdown.page.mdx`
+  //   - Transpiled: `/pages/markdown.page.mdx?import`
+  // But `?import` doesn't work with `/@fs/`:
+  //   - Not transpiled: /@fs/home/runner/work/reveal/reveal/examples/react-full/pages/markdown.page.mdx
+  //   - Not transpiled: /@fs/home/runner/work/reveal/reveal/examples/react-full/pages/markdown.page.mdx?import
+  if (clientEntry.endsWith("?import")) {
+    assert(clientEntry.startsWith("/"))
+    return clientEntry
+  }
+
+  assertPosixPath(clientEntry)
+  let filePath: string
+  if (clientEntry.startsWith("/")) {
+    filePath = pathShim(root, clientEntry)
+  } else {
+    if (clientEntry.startsWith("@@reveal/")) {
+      assert(clientEntry.endsWith(".js"))
+      try {
+        // For Vitest (which doesn't resolve reveal to its dist but to its source files)
+        // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/reveal/node/plugin/resolveClientEntriesDev.js
+        filePath = toPosixPath(
+          require_.resolve(
+            clientEntry
+              .replace("@@reveal/dist/client/", "../../client/")
+              .replace(".js", ".ts")
+          )
+        )
+      } catch {
+        // For users
+        // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/reveal/dist/node/plugin/resolveClientEntriesDev.js
+        filePath = toPosixPath(
+          require_.resolve(
+            clientEntry.replace(
+              "@@reveal/dist/client/",
+              "../../../../dist/client/"
+            )
+          )
+        )
+      }
+    } else {
+      assertIsNpmPackageImport(clientEntry)
+      filePath = require_.resolve(clientEntry)
+    }
+  }
+
+  if (!filePath.startsWith("/")) {
+    assert(process.platform === "win32")
+    filePath = "/" + filePath
+  }
+
+  filePath = "/@fs" + filePath
+  assertPosixPath(filePath)
+
+  return filePath
+}

package/dist/plugins/reveal/index.ts

@@ -0,0 +1,39 @@
+import { Plugin } from "vite";
+import vercel from "../vercel";
+import { removeUseClientServer } from "./remove-use-client-server";
+
+type RevealPlugin = Plugin & {
+  name: string;
+  enforce: "post";
+};
+
+const reveal: RevealPlugin = {
+  name: "reveal",
+  enforce: "post", // Make sure it runs after other plugins,
+  transform: removeUseClientServer.transform,
+  ...vercel,
+};
+
+reveal.name = "reveal";
+
+export default reveal;
+
+// const removeUseClientServer = {
+//     name: "remove-use-client-server",
+//     enforce: "pre", // Make sure it runs before other plugins
+//     transform(code: string, id: string) {
+//       // Apply the transformation to TypeScript files only (.ts and .tsx)
+//       if (id.endsWith(".tsx") || id.endsWith(".ts")) {
+//         // Regular expression to match both "use client" and "use server"
+//         const transformedCode = code.replace(
+//           /["']use (client|server)["'];?/g,
+//           ""
+//         )
+//         return {
+//           code: transformedCode,
+//           map: null, // Optionally provide sourcemaps
+//         }
+//       }
+//       return null
+//     },
+//   };