@revealui/core 0.0.1-pre.0

package/dist/plugins/vercel/index.ts

@@ -0,0 +1,186 @@
+export * from "../../+config.js";
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { Plugin, PluginOption, ResolvedConfig } from "vite";
+import type { ViteVercelPrerenderRoute } from "../../types/interfaces/host.js";
+import { buildEndpoints } from "./functions/build.js";
+import { writeConfig } from "./functions/config.js";
+import { copyDir } from "./functions/helpers.js";
+import { buildPrerenderConfigs, execPrerender } from "./functions/prerender.js";
+import { getOutput, getPublic } from "./functions/utils.js";
+
+type PluginVercelCleanup = Plugin & {
+  name: string;
+  enforce: "pre";
+  writeBundle: {
+    order: "pre";
+    sequential: true;
+    handler: () => Promise<void>;
+  };
+};
+
+type PluginVercelOptions = Plugin & {
+  name: string;
+  enforce: "post";
+  writeBundle: {
+    order: "post";
+    sequential: true;
+    handler: () => Promise<void>;
+  };
+};
+
+function vercelPluginCleanup(): PluginVercelCleanup {
+  let resolvedConfig: ResolvedConfig;
+
+  return {
+    apply: "build",
+    name: "reveal/vercel:cleanup",
+    enforce: "pre",
+    configResolved(config: ResolvedConfig) {
+      resolvedConfig = config;
+    },
+    writeBundle: {
+      order: "pre",
+      sequential: true,
+      async handler() {
+        if (!resolvedConfig.build?.ssr) {
+          await cleanOutputDirectory(resolvedConfig);
+        }
+      },
+    },
+  };
+}
+
+function vercelPlugin(): PluginVercelOptions {
+  let resolvedConfig: ResolvedConfig;
+  let revealFound = false;
+
+  return {
+    apply: "build",
+    name: "reveal/vercel",
+    enforce: "post",
+    configResolved(config: ResolvedConfig) {
+      resolvedConfig = config;
+      revealFound = resolvedConfig.plugins.some((p) =>
+        (p as { name: string }).name.match("^reveal/vercel:"),
+      );
+
+      // Safely set `distContainsOnlyStatic` without direct assignment
+      if (typeof config.vercel?.distContainsOnlyStatic === "undefined") {
+        // Create a new object to avoid modifying the original `resolvedConfig.vercel`
+        const updatedVercelConfig = {
+          ...config.vercel,
+          distContainsOnlyStatic: !revealFound,
+        };
+        // Reassign to `resolvedConfig` using Object.defineProperty
+        Object.defineProperty(resolvedConfig, "vercel", {
+          value: updatedVercelConfig,
+          writable: false,
+          enumerable: true,
+          configurable: true,
+        });
+      }
+    },
+    writeBundle: {
+      order: "post",
+      sequential: true,
+      async handler() {
+        if (!resolvedConfig.build?.ssr && revealFound) {
+          return;
+        }
+
+        const overrides = await execPrerender(resolvedConfig);
+        const userOverrides = await computeStaticHtmlOverrides(resolvedConfig);
+        const { rewrites, isr, headers } = await buildEndpoints(resolvedConfig);
+        rewrites.push(...(await buildPrerenderConfigs(resolvedConfig, isr)));
+
+        await writeConfig(
+          resolvedConfig,
+          rewrites,
+          { ...userOverrides, ...overrides },
+          headers,
+        );
+        await copyDistToStatic(resolvedConfig);
+      },
+    },
+  };
+}
+
+async function cleanOutputDirectory(resolvedConfig: ResolvedConfig) {
+  await fs.rm(getOutput(resolvedConfig), { recursive: true, force: true });
+  await fs.mkdir(getOutput(resolvedConfig), { recursive: true });
+}
+
+async function copyDistToStatic(resolvedConfig: ResolvedConfig) {
+  if (resolvedConfig.vercel?.distContainsOnlyStatic) {
+    await copyDir(
+      resolvedConfig.build.outDir,
+      getOutput(resolvedConfig, "static"),
+    );
+  }
+}
+
+async function computeStaticHtmlOverrides(
+  resolvedConfig: ResolvedConfig,
+): Promise<NonNullable<ViteVercelPrerenderRoute>> {
+  const staticAbsolutePath = getOutput(resolvedConfig, "static");
+  const files = await getStaticHtmlFiles(staticAbsolutePath);
+  const publicDir = getPublic(resolvedConfig);
+  const publicFiles = await getStaticHtmlFiles(publicDir);
+  files.push(
+    ...publicFiles.map((f) => f.replace(publicDir, staticAbsolutePath)),
+  );
+
+  return files.reduce((acc, curr) => {
+    const relPath = path.relative(staticAbsolutePath, curr);
+    const parsed = path.parse(relPath);
+    const pathShimed = path.join(parsed.dir, parsed.name);
+    acc[relPath] = { path: pathShimed };
+    return acc;
+  }, {} as NonNullable<ViteVercelPrerenderRoute>);
+}
+
+async function getStaticHtmlFiles(src: string): Promise<string[]> {
+  try {
+    const stats = await fs.stat(src);
+    if (!stats.isDirectory()) return [];
+  } catch (e) {
+    console.warn(`Warning: Directory ${src} does not exist. Skipping...`);
+    return [];
+  }
+
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  const htmlFiles: string[] = [];
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    if (entry.isDirectory()) {
+      htmlFiles.push(...(await getStaticHtmlFiles(srcPath)));
+    } else if (srcPath.endsWith(".html")) {
+      htmlFiles.push(srcPath);
+    }
+  }
+  return htmlFiles;
+}
+
+async function tryImportVpvv(options: any) {
+  try {
+    const { default: vpvv } = await import("reveal/vercel");
+    if (typeof vpvv === "function") {
+      return vpvv(options) as PluginOption;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+export default function vercel(options: any = {}): PluginOption[] {
+  const { smart, ...rest } = options;
+  return [
+    vercelPluginCleanup(),
+    vercelPlugin(),
+    smart !== false ? tryImportVpvv(rest) : null,
+  ];
+}

package/dist/plugins/vercel/plugin.ts

@@ -0,0 +1,45 @@
+/**
+ * Vercel plugin wrapper for RevealUI plugin system
+ * Wraps the existing Vercel plugin to work with the new plugin API
+ */
+
+import { createRevealPlugin } from "../../plugin/index.js";
+import type { RevealPlugin } from "../../plugin/index.js";
+import vercelPluginFactory from "./index.js";
+
+export interface VercelPluginOptions {
+  /**
+   * Enable smart mode (auto-detection)
+   * @default true
+   */
+  smart?: boolean;
+
+  /**
+   * Additional Vercel-specific options
+   */
+  [key: string]: unknown;
+}
+
+/**
+ * Vercel plugin factory for RevealUI plugin system
+ */
+export const vercel = createRevealPlugin<VercelPluginOptions>(
+  "reveal:vercel",
+  (options = {}) => {
+    const plugin: Omit<RevealPlugin, "name"> = {
+      version: "1.0.0",
+      dependencies: [],
+      revealConfigResolved(context) {
+        // Vercel plugin is applied during build
+        // This hook ensures Vercel-specific config is set
+      },
+      // Convert to Vite plugin
+      ...vercelPluginFactory(options),
+    };
+
+    return plugin;
+  }
+);
+
+export default vercel;
+

package/dist/plugins/vercel/schemas/config/prerender-config.ts

@@ -0,0 +1,20 @@
+/**
+ * Schema definition for `.vercel/output/config.json`
+ * @see {@link https://vercel.com/docs/build-output-api/v3#build-output-configuration}
+ */
+
+import { z } from "zod";
+
+export const vercelOutputPrerenderConfigSchema = z
+  .object({
+    expiration: z.union([z.number().int().positive(), z.literal(false)]),
+    group: z.number().int().optional(),
+    bypassToken: z.string().optional(),
+    fallback: z.string().optional(),
+    allowQuery: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export type VercelOutputPrerenderConfig = z.infer<
+  typeof vercelOutputPrerenderConfigSchema
+>;

package/dist/plugins/vercel/schemas/config/vc-config.ts

@@ -0,0 +1,45 @@
+/**
+ * Schema definition for `.vercel/output/functions/<name>.func/.vc-config.json`
+ * @see {@link https://vercel.com/docs/build-output-api/v3/primitives#serverless-function-configuration}
+ */
+
+import { z } from "zod";
+
+export const vercelOutputEdgeVcConfigSchema = z
+  .object({
+    runtime: z.literal("edge"),
+    entrypoint: z.string(),
+    envVarsInUse: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export const vercelOutputServerlessVcConfigSchema = z
+  .object({
+    runtime: z.string(),
+    handler: z.string(),
+    memory: z.number().int().min(128).max(3008).optional(),
+    maxDuration: z.number().int().positive().optional(),
+    environment: z.record(z.string(), z.string()).optional(),
+    regions: z.array(z.string()).optional(),
+    supportsWrapper: z.boolean().optional(),
+    supportsResponseStreaming: z.boolean().optional(),
+  })
+  .strict();
+
+export const vercelOutputServerlessNodeVcConfigSchema =
+  vercelOutputServerlessVcConfigSchema
+    .extend({
+      launcherType: z.literal("Nodejs"),
+      shouldAddHelpers: z.boolean().optional(),
+      shouldAddSourcemapSupport: z.boolean().optional(),
+      awsLambdaHandler: z.string().optional(),
+    })
+    .strict();
+
+export const vercelOutputVcConfigSchema = z.union([
+  vercelOutputEdgeVcConfigSchema,
+  vercelOutputServerlessVcConfigSchema,
+  vercelOutputServerlessNodeVcConfigSchema,
+]);
+
+export type VercelOutputVcConfig = z.infer<typeof vercelOutputVcConfigSchema>;

package/dist/plugins/vercel/schemas/config/vercel.ts

@@ -0,0 +1,130 @@
+/**
+ * Schema definition for `.vercel/output/config.json`
+ * @see {@link https://vercel.com/docs/build-output-api/v3#build-output-configuration}
+ */
+
+import { z } from "zod";
+
+const HasOrMissing = z
+  .array(
+    z.union([
+      z
+        .object({
+          type: z.literal("host"),
+          value: z.string(),
+        })
+        .strict(),
+      z
+        .object({
+          type: z.literal("header"),
+          key: z.string(),
+          value: z.string().optional(),
+        })
+        .strict(),
+      z
+        .object({
+          type: z.literal("cookie"),
+          key: z.string(),
+          value: z.string().optional(),
+        })
+        .strict(),
+      z
+        .object({
+          type: z.literal("query"),
+          key: z.string(),
+          value: z.string().optional(),
+        })
+        .strict(),
+    ]),
+  )
+  .optional();
+
+export const vercelOutputConfigSchema = z
+  .object({
+    version: z.literal(3),
+    routes: z
+      .array(
+        z.union([
+          z
+            .object({
+              src: z.string(),
+              dest: z.string().optional(),
+              headers: z.record(z.string(), z.string()).optional(),
+              methods: z.array(z.string()).optional(),
+              status: z.number().int().positive().optional(),
+              continue: z.boolean().optional(),
+              check: z.boolean().optional(),
+              missing: HasOrMissing,
+              has: HasOrMissing,
+              locale: z
+                .object({
+                  redirect: z.record(z.string(), z.string()).optional(),
+                  cookie: z.string().optional(),
+                })
+                .strict()
+                .optional(),
+              middlewarePath: z.string().optional(),
+            })
+            .strict(),
+          z
+            .object({
+              handle: z.union([
+                z.literal("rewrite"),
+                z.literal("filesystem"),
+                z.literal("resource"),
+                z.literal("miss"),
+                z.literal("hit"),
+                z.literal("error"),
+              ]),
+              src: z.string().optional(),
+              dest: z.string().optional(),
+              status: z.number().optional(),
+            })
+            .strict(),
+        ]),
+      )
+      .optional(),
+    images: z
+      .object({
+        sizes: z.tuple([
+          z.number().int().positive(),
+          z.number().int().positive(),
+        ]),
+        domains: z.array(z.string()).nonempty().optional(),
+        minimumCacheTTL: z.number().int().positive().optional(),
+        formats: z
+          .union([z.literal("image/avif"), z.literal("image/webp")])
+          .array()
+          .nonempty()
+          .optional(),
+        dangerouslyAllowSVG: z.boolean().optional(),
+        contentSecurityPolicy: z.string().optional(),
+      })
+      .strict()
+      .optional(),
+    wildcard: z
+      .array(
+        z
+          .object({
+            domain: z.string(),
+            value: z.string(),
+          })
+          .strict(),
+      )
+      .optional(),
+    overrides: z
+      .record(
+        z.string(),
+        z
+          .object({
+            path: z.string().optional(),
+            contentType: z.string().optional(),
+          })
+          .strict(),
+      )
+      .optional(),
+    cache: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export type VercelOutputConfig = z.infer<typeof vercelOutputConfigSchema>;

package/dist/plugins/vercel/schemas/exports.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const vercelEndpointExports = z.object({
+  edge: z.boolean().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  streaming: z.boolean().optional(),
+  isr: z
+    .object({
+      expiration: z.number().or(z.literal(false)),
+    })
+    .optional(),
+});

package/dist/plugins/vercel/templates/edge-helpers.ts

@@ -0,0 +1,72 @@
+import { parse } from "qs"
+import type { renderPage } from "vike/server"
+import { getOriginalUrl } from "./utils"
+
+type HttpResponse = NonNullable<
+  Awaited<ReturnType<typeof renderPage>>["httpResponse"]
+>
+
+/**
+ * Extract useful pageContext from request to give to renderPage(...).
+ * It handles internals such as retrieving the original url from `x-now-route-matches` header or from `__original_path` query,
+ * so it's highly recommended to use it instead of `request.url`.
+ * @param request
+ */
+export function getDefaultPageContextInit(request: Request) {
+  const queryString = new URL(request.url).search.slice(1) // Remove the leading "?" with .slice(1)
+  const query = parse(queryString)
+  const routeMatchesHeader =
+    request.headers.get("x-now-route-matches") ?? undefined
+  const originalPath = Array.isArray(query.__original_path)
+    ? query.__original_path[0]
+    : query.__original_path
+  const url = getOriginalUrl(
+    routeMatchesHeader,
+    typeof originalPath === "string" ? originalPath : undefined,
+    request.url
+  )
+  const cookieHeader = request.headers.get("Cookie") || ""
+
+  const cookies = cookieHeader.split("; ").reduce(
+    (acc, cookie) => {
+      const [name, value] = cookie.split("=")
+      if (name) {
+        acc[name] = value || ""
+      }
+      return acc
+    },
+    {} as Record<string, string>
+  )
+
+  return {
+    urlOriginal: url,
+    body: request.body,
+    cookies,
+  }
+}
+
+/**
+ * Send a default empty HTML response
+ */
+export function getDefaultEmptyResponseHandler(): Response {
+  return new Response(null, {
+    status: 200,
+    headers: {
+      "content-type": "text/html; charset=UTF-8",
+    },
+  })
+}
+
+/**
+ * Send `httpResponse` through `response`
+ */
+export function getDefaultResponseHandler(
+  httpResponse: HttpResponse
+): Response {
+  const { statusCode, body, headers } = httpResponse
+
+  return new Response(body, {
+    status: statusCode,
+    headers,
+  })
+}

package/dist/plugins/vercel/templates/node-helpers.ts

@@ -0,0 +1,60 @@
+import type { VercelRequest, VercelResponse } from "@vercel/node"
+import type { renderPage } from "vike/server"
+import { getOriginalUrl } from "./utils"
+
+type HttpResponse = NonNullable<
+  Awaited<ReturnType<typeof renderPage>>["httpResponse"]
+>
+
+/**
+ * Extract useful pageContext from request to give to renderPage(...).
+ * It handles internals such as retrieving the original url from `x-now-route-matches` header or from `__original_path` query,
+ * so it's highly recommended to use it instead of `request.url`.
+ * @param request
+ */
+export function getDefaultPageContextInit(request: VercelRequest) {
+  const query: Record<string, string | string[]> = request.query ?? {}
+  const routeMatchesHeader = Array.isArray(
+    request.headers["x-now-route-matches"]
+  )
+    ? request.headers["x-now-route-matches"][0] // Take the first entry if it's an array
+    : request.headers["x-now-route-matches"]
+  const originalPath = Array.isArray(query.__original_path)
+    ? query.__original_path[0]
+    : query.__original_path
+  const url = getOriginalUrl(routeMatchesHeader, originalPath, request.url)
+  return {
+    url,
+    urlOriginal: url,
+    body: request.body,
+    cookies: request.cookies,
+  }
+}
+
+/**
+ * Send a default empty HTML response
+ * @param response
+ */
+export function getDefaultEmptyResponseHandler(response: VercelResponse) {
+  response.statusCode = 200
+  response.setHeader("content-type", "text/html; charset=UTF-8")
+  return response.end("")
+}
+
+/**
+ * Send `httpResponse` through `response`
+ * @param response
+ * @param httpResponse
+ */
+export function getDefaultResponseHandler(
+  response: VercelResponse,
+  httpResponse: HttpResponse
+) {
+  const { statusCode, body, headers } = httpResponse
+
+  response.statusCode = statusCode
+  for (const [name, value] of headers) {
+    response.setHeader(name, value)
+  }
+  return response.end(body)
+}

package/dist/plugins/vercel/templates/ssr_.template.ts

@@ -0,0 +1,25 @@
+import type { VercelRequest, VercelResponse } from "@vercel/node"
+import { renderPage } from "vike/server"
+import {
+  getDefaultEmptyResponseHandler,
+  getDefaultPageContextInit,
+  getDefaultResponseHandler,
+} from "./node-helpers"
+
+export default async function handler(
+  request: VercelRequest,
+  response: VercelResponse
+) {
+  console.debug("query", request.query)
+  console.debug("url", request.url)
+  console.debug("headers", request.headers)
+  const pageContextInit = getDefaultPageContextInit(request)
+  const pageContext = await renderPage(pageContextInit)
+  const { httpResponse } = pageContext
+
+  if (!httpResponse) {
+    return getDefaultEmptyResponseHandler(response)
+  }
+
+  return getDefaultResponseHandler(response, httpResponse)
+}

package/dist/plugins/vercel/templates/ssr_edge_.template.ts

@@ -0,0 +1,20 @@
+import { renderPage } from "vike/server"
+import {
+  getDefaultEmptyResponseHandler,
+  getDefaultPageContextInit,
+  getDefaultResponseHandler,
+} from "./edge-helpers"
+
+export default async function handler(request: Request): Promise<Response> {
+  console.debug("url", request.url)
+  console.debug("headers", request.headers)
+  const pageContextInit = getDefaultPageContextInit(request)
+  const pageContext = await renderPage(pageContextInit)
+  const { httpResponse } = pageContext
+
+  if (!httpResponse) {
+    return getDefaultEmptyResponseHandler()
+  }
+
+  return getDefaultResponseHandler(httpResponse)
+}

package/dist/plugins/vercel/templates/utils.ts

@@ -0,0 +1,31 @@
+import { parse } from "qs";
+
+export function getOriginalUrl(
+  xNowRouteMatchesHeader: string | undefined,
+  originalPath: string | undefined,
+  url?: string,
+): string {
+  // Parse the route matches header if it's a string
+  const matches =
+    typeof xNowRouteMatchesHeader === "string"
+      ? parse(xNowRouteMatchesHeader)
+      : null;
+
+  // Determine the original URL
+  return typeof originalPath === "string"
+    ? originalPath
+    : matches && typeof matches["1"] === "string"
+      ? matches["1"]
+      : (url ?? "");
+}
+
+// export function getOriginalUrl(xNowRouteMatchesHeader: unknown, originalPath: unknown, url?: string) {
+//   const matches =
+//     // FIXME x-now-route-matches is not definitive https://github.com/orgs/vercel/discussions/577#discussioncomment-2769478
+//     typeof xNowRouteMatchesHeader === "string" ? parse(xNowRouteMatchesHeader) : null;
+//   return typeof originalPath === "string"
+//     ? originalPath
+//     : matches && typeof matches?.["1"] === "string"
+//       ? matches["1"]
+//       : url ?? "";
+// }

package/dist/plugins/workaroundCssModuleHmr.ts

@@ -0,0 +1,23 @@
+export { workaroundCssModuleHmr }
+
+// https://github.com/revealjs/reveal/issues/1127#issuecomment-2294511748
+
+import type { PluginOption } from "vite"
+
+type PluginCssModuleHmr = PluginOption & {
+  name: string
+  handleHotUpdate: (ctx: { file: string; modules: { id: string }[] }) => void
+}
+
+function workaroundCssModuleHmr(): PluginCssModuleHmr {
+  return {
+    name: "reveal:workaroundCssModuleHmr",
+    handleHotUpdate(ctx) {
+      // prevent full reload due to non self-accepting css module.
+      // here only "?direct" module should be filtered out as it doesn't have a parent module.
+      if (ctx.file.includes("module.css")) {
+        return ctx.modules.filter((m) => !m.id?.includes("?direct"))
+      }
+    },
+  }
+}