@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

package/dist/plugins/vercel/index.ts

@@ -1,186 +0,0 @@
-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

@@ -1,45 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,45 +0,0 @@
-/**
- * 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

@@ -1,130 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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"))
-      }
-    },
-  }
-}