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

package/dist/plugins/buildConfig/injectRollupInputs.ts

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

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

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

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

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