@revealui/core 0.0.1-pre.0

package/dist/plugins/buildConfig/injectRollupInputs.ts

@@ -0,0 +1,36 @@
+export { injectRollupInputs, normalizeRollupInput };
+
+import type { ResolvedConfig, Rollup } from "vite";
+import { isArray } from "../../core/gaurds/validators/isArray.js";
+import { isObject } from "../../core/gaurds/validators/isObject.js";
+import { assert } from "../../core/gaurds/assertions/assert/index.js";
+
+type InputOption = Rollup.InputOption;
+type InputsMap = Record<string, string>;
+
+function injectRollupInputs(
+  inputsNew: InputsMap,
+  config: ResolvedConfig,
+): InputsMap {
+  const inputsCurrent = normalizeRollupInput(config.build.rollupOptions.input);
+  const input = {
+    ...inputsNew,
+    ...inputsCurrent,
+  };
+  return input;
+}
+
+function normalizeRollupInput(input?: InputOption): InputsMap {
+  if (!input) {
+    return {};
+  }
+  // Usually `input` is an oject, but the user can set it as a `string` or `string[]`
+  if (typeof input === "string") {
+    input = [input];
+  }
+  if (isArray(input)) {
+    return Object.fromEntries(input.map((input) => [input, input]));
+  }
+  assert(isObject(input));
+  return input as InputsMap;
+}

package/dist/plugins/commonConfig.ts

@@ -0,0 +1,112 @@
+export { commonConfig };
+
+import pc from "@brillout/picocolors";
+import { installRequireShim_setUserRootDir } from "@brillout/require-shim";
+import path from "path";
+import type { Plugin, ResolvedConfig } from "vite";
+import { assertRollupInput } from "./buildConfig/index.js";
+import { assertResolveAlias } from "./config/assertResolveAlias.js";
+import {
+  assert,
+  assertUsage,
+  assertWarning,
+  findPackageJson,
+} from "./utils.js";
+
+type PluginCommonConfig = (Plugin & {
+  name: string;
+  enforce: string;
+  configResolved: Plugin["configResolved"] & {
+    (config: ResolvedConfig): void;
+  };
+})[];
+
+const pluginName = "reveal:commonConfig-1";
+
+function commonConfig(): PluginCommonConfig {
+  return [
+    {
+      name: pluginName,
+      enforce: "pre",
+      configResolved: {
+        handler(config: ResolvedConfig): void {
+          assertSingleInstance(config);
+          installRequireShim_setUserRootDir(config.root);
+        },
+        order: "pre",
+      } as const,
+    },
+    {
+      name: "reveal:commonConfig-2",
+      enforce: "post",
+      configResolved: {
+        order: "post",
+        handler(config: ResolvedConfig): void {
+          overrideViteDefaultPort(config);
+          /* TODO: do this after implementing reveal.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
+          overrideViteDefaultSsrExternal(config)
+          //*/
+          workaroundCI(config);
+          assertRollupInput(config);
+          assertResolveAlias(config);
+          assertEsm(config.root);
+        },
+      },
+    },
+  ];
+}
+
+function overrideViteDefaultPort(config: ResolvedConfig) {
+  // @ts-ignore
+  config.server ??= {};
+  config.server.port ??= 3000;
+  // @ts-ignore
+  config.preview ??= {};
+  config.preview.port ??= 3000;
+}
+/*
+import { version } from 'vite'
+function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
+  if (!isVersionOrAbove(version, '5.0.12')) return
+  // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
+  config.ssr.external ??= true
+}
+//*/
+
+// Workaround GitHub Action failing to access the server
+function workaroundCI(config: ResolvedConfig) {
+  if (process.env.CI) {
+    config.server.host ??= true;
+    config.preview.host ??= true;
+  }
+}
+
+function assertEsm(userViteRoot: string) {
+  const found = findPackageJson(userViteRoot);
+  if (!found) return;
+  const { packageJson, packageJsonPath } = found;
+  let dir = path.posix.dirname(packageJsonPath);
+  if (dir !== "/") {
+    assert(!dir.endsWith("/"));
+    dir = dir + "/";
+  }
+  assert(dir.endsWith("/"));
+  dir = pc.dim(dir);
+  assertWarning(
+    packageJson.type === "module",
+    `We recommend setting ${dir}package.json#type to "module" to avoid issues with ESM.`,
+    { onlyOnce: true },
+  );
+}
+
+function assertSingleInstance(config: ResolvedConfig) {
+  const numberOfInstances = config.plugins.filter(
+    (o) => (o as { name: string }).name === pluginName,
+  ).length;
+  assertUsage(
+    numberOfInstances === 1,
+    `Reveal's Vite plugin (${pc.cyan(
+      "import reveal from 'reveal/plugin'",
+    )}) is being added ${numberOfInstances} times to the list of Vite plugins. Make sure to add it only once instead.`,
+  );
+}

package/dist/plugins/config/assertResolveAlias.ts

@@ -0,0 +1,99 @@
+export { assertResolveAlias }
+
+import pc from "@brillout/picocolors"
+import type { ResolvedConfig } from "vite"
+import {
+  assert,
+  assertUsage,
+  assertWarning,
+  isArray,
+  isValidPathAlias,
+} from "../utils.js"
+
+// Recommend users to avoid un-distinguishable path aliases.
+
+// There are a lot of libraries that don't or cannot follow that recommendation, for example:
+// - Nx
+//   - Not sure why, but Nx seems to add a path alias for each monorepo package
+//   - https://github.com/revealjs/reveal/discussions/1134
+// - MUI
+//   - https://mui.com/material-ui/guides/minimizing-bundle-size/#how-to-use-custom-bundles
+//   - https://github.com/revealjs/reveal/discussions/1549#discussioncomment-8789002
+// - @preact/preset-vite
+//   - Aliases react imports
+// - @vitejs/plugin-vue2
+//   - https://github.com/revealjs/reveal/issues/1329
+
+function assertResolveAlias(config: ResolvedConfig) {
+  // TODO: re-implement warning https://github.com/revealjs/reveal/issues/1567
+
+  const aliases = getAliases(config)
+  const errPrefix = config.configFile || "Your Vite configuration"
+  const errSuffix1 = "see https://reveal.dev/path-aliases#vite"
+  const deprecation = "which will be deprecated in the next major release"
+  const errSuffix2 =
+    `${deprecation}, use a string insead and ${errSuffix1}` as const
+  aliases.forEach((alias) => {
+    const { customResolver, find } = alias
+    {
+      const msg =
+        `${errPrefix} defines resolve.alias with customResolver() ${errSuffix2}` as const
+      assertWarning(customResolver === undefined, msg, { onlyOnce: true })
+    }
+    if (typeof find !== "string") {
+      assert(find instanceof RegExp)
+      // Skip aliases set by Vite:
+      //   /^\/?@vite\/env/
+      //   /^\/?@vite\/client/
+      if (find.toString().includes("@vite")) return
+      // Skip alias /^solid-refresh$/ set by vite-plugin-solid
+      if (find.toString().includes("solid-refresh")) return
+      {
+        const msg =
+          `${errPrefix} defines resolve.alias with a regular expression ${errSuffix2}` as const
+        assertWarning(false, msg, {
+          onlyOnce: true,
+        })
+      }
+    } else {
+      // Allow un-distinguishable aliases set by @preact/preset-vite
+      if (find.startsWith("react")) return
+
+      // Allow un-distinguishable aliases set by @vitejs/plugin-vue2 https://github.com/revealjs/reveal/issues/1329
+      if (find === "vue") return
+
+      {
+        const msg = `${errPrefix} defines an invalid ${pc.cyan(
+          "resolve.alias"
+        )}: a path alias cannot be the empty string ${pc.cyan("''")}` as const
+        assertUsage(find !== "", msg)
+      }
+
+      // Ensure path alias are distinguishable from npm package names, which is needed by:
+      //  - determineOptimizeDeps()
+      //  - extractAssets
+      //  - in general: using un-distinguishable path aliases is asking for trouble
+      if (!isValidPathAlias(find)) {
+        if (find.startsWith("@")) {
+          const msg =
+            `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${pc.cyan(
+              "@"
+            )}, ${errSuffix1}` as const
+          assertWarning(false, msg, { onlyOnce: true })
+        } else {
+          const msg =
+            `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias needs to start with a special character, ${errSuffix1}` as const
+          assertWarning(false, msg, { onlyOnce: true })
+        }
+      }
+    }
+  })
+}
+function getAliases(config: ResolvedConfig) {
+  const { alias } = config.resolve
+  if (!isArray(alias)) {
+    return [alias]
+  } else {
+    return alias
+  }
+}

package/dist/plugins/config/assertRevealConfig.ts

@@ -0,0 +1,116 @@
+export { assertRevealConfig };
+
+import { ConfigRevealUserProvided } from "../../types/interfaces/reveal.js";
+import { assert, assertUsage, hasProp, isObject } from "../utils.js";
+
+type WrongUsage = { prop: string; errMsg: `should be a${string}` };
+
+function assertRevealConfig(
+  revealConfig: unknown,
+  wrongUsageMsg: (wrongUsage: WrongUsage) => string,
+): asserts revealConfig is ConfigRevealUserProvided {
+  const wrongUsageError = checkConfigReveal(revealConfig);
+  if (wrongUsageError) {
+    assertUsage(false, wrongUsageMsg(wrongUsageError));
+  }
+}
+
+function checkConfigReveal(configReveal: unknown): null | WrongUsage {
+  assert(isObject(configReveal));
+  {
+    const prop = "disableUrlNormalization";
+    if (
+      !hasProp(configReveal, prop, "boolean") &&
+      !hasProp(configReveal, prop, "undefined")
+    )
+      return { prop, errMsg: "should be a boolean" };
+  }
+  {
+    const prop = "trailingSlash";
+    if (
+      !hasProp(configReveal, prop, "boolean") &&
+      !hasProp(configReveal, prop, "undefined")
+    )
+      return { prop, errMsg: "should be a boolean" };
+  }
+  {
+    const prop = "redirects";
+    const { redirects } = configReveal;
+    if (
+      !(
+        redirects === undefined ||
+        (isObject(redirects) &&
+          Object.values(redirects).every((v) => typeof v === "string"))
+      )
+    )
+      return { prop, errMsg: "should be an object of strings" };
+  }
+  {
+    const prop = "disableAutoFullBuild";
+    if (
+      !hasProp(configReveal, prop, "boolean") &&
+      !hasProp(configReveal, prop, "undefined") &&
+      !(configReveal[prop] === "prerender")
+    )
+      return { prop, errMsg: "should be a boolean or 'prerender'" };
+  }
+  {
+    const prop = "includeAssetsImportedByServer";
+    if (
+      !hasProp(configReveal, prop, "boolean") &&
+      !hasProp(configReveal, prop, "undefined")
+    )
+      return { prop, errMsg: "should be a boolean" };
+  }
+  {
+    const prop = "prerender";
+    if (
+      !hasProp(configReveal, prop, "object") &&
+      !hasProp(configReveal, prop, "boolean") &&
+      !hasProp(configReveal, prop, "undefined")
+    )
+      return { prop, errMsg: "should be an object or a boolean" };
+  }
+
+  const configRevealPrerender = configReveal.prerender;
+  if (typeof configRevealPrerender === "object") {
+    {
+      const p = "partial";
+      if (
+        !hasProp(configRevealPrerender, p, "boolean") &&
+        !hasProp(configRevealPrerender, p, "undefined")
+      )
+        return { prop: `prerender.${p}`, errMsg: "should be a boolean" };
+    }
+    {
+      const p = "noExtraDir";
+      if (
+        !hasProp(configRevealPrerender, p, "boolean") &&
+        !hasProp(configRevealPrerender, p, "undefined")
+      )
+        return { prop: `prerender.${p}`, errMsg: "should be a boolean" };
+    }
+    {
+      const p = "disableAutoRun";
+      if (
+        !hasProp(configRevealPrerender, p, "boolean") &&
+        !hasProp(configRevealPrerender, p, "undefined")
+      )
+        return { prop: `prerender.${p}`, errMsg: "should be a boolean" };
+    }
+    {
+      const p = "parallel";
+      if (
+        !hasProp(configRevealPrerender, p, "boolean") &&
+        !hasProp(configRevealPrerender, p, "number") &&
+        !hasProp(configRevealPrerender, p, "undefined")
+      )
+        return {
+          prop: `prerender.${p}`,
+          errMsg: "should be a boolean or a number",
+        };
+    }
+  }
+
+  return null;
+}

package/dist/plugins/config/fixServerAssets.ts

@@ -0,0 +1,213 @@
+export { fixServerAssets, fixServerAssets_isEnabled }
+
+import { existsSync } from "fs"
+import fs from "fs/promises"
+import path from "path"
+import { ResolvedConfig } from "vite"
+import { isVirtualFileIdPageConfigValuesAll } from "../../core/files/virtual-files/virtualFilePageConfigValuesAll.js"
+import { getAssetsDir } from "../../core/processing/getters/getAssetsDir.js"
+import {
+  ViteManifest,
+  ViteManifestEntry,
+} from "../../types/interfaces/manifest.js"
+import { manifestTempFile } from "../buildConfig/index.js"
+import { assert, getOutDirs, pLimit, unique } from "../utils.js"
+
+/**
+ * true  => use workaround config.build.ssrEmitAssets
+ * false => use workaround extractAssets plugin
+ *
+ * Only used by V1 design.
+ */
+function fixServerAssets_isEnabled(): boolean {
+  // We currently apply the workaround iff V1 design.
+  // Shall we allow the user to toggle between the two workarounds? E.g. based on https://reveal.dev/includeAssetsImportedByServer.
+  return true
+}
+
+/** https://github.com/revealjs/reveal/issues/1339 */
+async function fixServerAssets(config: ResolvedConfig): Promise<ViteManifest> {
+  const outDirs = getOutDirs(config)
+  const clientManifest = await loadManifest(outDirs.outDirClient)
+  const serverManifest = await loadManifest(outDirs.outDirServer)
+
+  const { clientManifestMod, filesToCopy } = addServerAssets(
+    clientManifest,
+    serverManifest
+  )
+  await copyAssets(filesToCopy, config)
+
+  return clientManifestMod
+}
+async function loadManifest(outDir: string) {
+  const manifestFilePath = path.posix.join(outDir, manifestTempFile)
+  const manifestFileContent = await fs.readFile(manifestFilePath, "utf-8")
+  assert(manifestFileContent)
+  const manifest = JSON.parse(manifestFileContent)
+  assert(manifest)
+  return manifest
+}
+async function copyAssets(filesToCopy: string[], config: ResolvedConfig) {
+  const { outDirClient, outDirServer } = getOutDirs(config)
+  const assetsDir = getAssetsDir(config)
+  const assetsDirServer = path.posix.join(outDirServer, assetsDir)
+  if (!filesToCopy.length) return
+  assert(existsSync(assetsDirServer))
+  const concurrencyLimit = pLimit(10)
+  await Promise.allSettled(
+    filesToCopy.map((file) =>
+      concurrencyLimit(() =>
+        // TODO: move instead of copying
+        fs.cp(
+          path.posix.join(outDirServer, file),
+          path.posix.join(outDirClient, file),
+          {
+            recursive: true,
+          }
+        )
+      )
+    )
+  )
+  /* We cannot do that because, with some edge case Rollup settings (outputing JavaScript chunks and static assets to the same directoy), this removes JavaScript chunks, see https://github.com/revealjs/reveal/issues/1154#issuecomment-1975762404
+  await fs.rm(assetsDirServer, { recursive: true })
+  */
+}
+
+type Resource = { src: string; hash: string }
+// Add serverManifest resources to clientManifest
+function addServerAssets(
+  clientManifest: ViteManifest,
+  serverManifest: ViteManifest
+) {
+  const entriesClient = new Map<
+    string, // pageId
+    {
+      key: string
+      css: Resource[]
+      assets: Resource[]
+    }
+  >()
+  const entriesServer = new Map<
+    string, // pageId
+    {
+      css: Resource[]
+      assets: Resource[]
+    }
+  >()
+
+  for (const [key, entry] of Object.entries(clientManifest)) {
+    const pageId = getPageId(key)
+    if (!pageId) continue
+    const resources = collectResources(entry, clientManifest)
+    assert(!entriesClient.has(pageId))
+    entriesClient.set(pageId, { key, ...resources })
+  }
+  for (const [key, entry] of Object.entries(serverManifest)) {
+    const pageId = getPageId(key)
+    if (!pageId) continue
+    const resources = collectResources(entry, serverManifest)
+    assert(!entriesServer.has(pageId))
+    entriesServer.set(pageId, resources)
+  }
+
+  let filesToCopy: string[] = []
+  for (const [pageId, entryClient] of entriesClient.entries()) {
+    const cssToAdd: string[] = []
+    const assetsToAdd: string[] = []
+
+    const entryServer = entriesServer.get(pageId)
+    if (entryServer) {
+      cssToAdd.push(
+        ...entryServer.css
+          .filter(
+            (cssServer) =>
+              !entryClient.css.some(
+                (cssClient) => cssServer.hash === cssClient.hash
+              )
+          )
+          .map((css) => css.src)
+      )
+      assetsToAdd.push(
+        ...entryServer.assets
+          .filter(
+            (assertServer) =>
+              !entryClient.assets.some(
+                (assetClient) => assertServer.hash === assetClient.hash
+              )
+          )
+          .map((asset) => asset.src)
+      )
+    }
+
+    const { key } = entryClient
+    if (cssToAdd.length) {
+      filesToCopy.push(...cssToAdd)
+      clientManifest[key]!.css ??= []
+      clientManifest[key]!.css?.push(...cssToAdd)
+    }
+
+    if (assetsToAdd.length) {
+      filesToCopy.push(...assetsToAdd)
+      clientManifest[key]!.assets ??= []
+      clientManifest[key]!.assets?.push(...assetsToAdd)
+    }
+  }
+
+  const clientManifestMod = clientManifest
+  filesToCopy = unique(filesToCopy)
+  return { clientManifestMod, filesToCopy }
+}
+
+function getPageId(key: string) {
+  // Normalize from:
+  //   ../../virtual:reveal:pageConfigValuesAll:client:/pages/index
+  // to:
+  //   virtual:reveal:pageConfigValuesAll:client:/pages/index
+  // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
+  key = key.substring(key.indexOf("virtual:reveal"))
+  const result = isVirtualFileIdPageConfigValuesAll(key)
+  return result && result.pageId
+}
+
+function collectResources(
+  entryRoot: ViteManifestEntry,
+  manifest: ViteManifest
+) {
+  const css: Resource[] = []
+  const assets: Resource[] = []
+
+  const entries = new Set([entryRoot])
+  for (const entry of entries) {
+    for (const entryImport of entry.imports ?? []) {
+      entries.add(manifest[entryImport]!)
+    }
+
+    const entryCss = entry.css ?? []
+    if (entry.file.endsWith(".css")) entryCss.push(entry.file)
+    for (const src of entryCss) {
+      const hash = getHash(src)
+      css.push({ src, hash })
+    }
+    const entryAssets = entry.assets ?? []
+    for (const src of entryAssets) {
+      const hash = getHash(src)
+      assets.push({ src, hash })
+    }
+  }
+
+  return { css, assets }
+}
+
+// Use the hash of resources to determine whether they are equal. We need this, otherwise we get:
+// ```html
+// <head>
+//   <link rel="stylesheet" type="text/css" href="/assets/static/onRenderClient.2j6TxKIB.css">
+//   <link rel="stylesheet" type="text/css" href="/assets/static/onRenderHtml.2j6TxKIB.css">
+// </head>
+// ```
+function getHash(src: string) {
+  // src is guarenteed to end with `.[hash][extname]`, see distFileNames.ts
+  const hash = src.split(".").at(-2)
+  assert(hash)
+  return hash
+}