@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getMostSimilar.ts

@@ -0,0 +1,72 @@
+export { getMostSimilar };
+
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { assertIsNotBrowser } from "../../gaurds/assertions/assertIsNotBrowser/index.js";
+import { higherFirst } from "../../utils/array/sorter.js";
+
+assertIsNotBrowser();
+
+function getMostSimilar(word: string, words: string[]): null | string {
+  if (words.length === 0) return null;
+
+  const exactMatch = words.find((w) => w === word);
+  if (exactMatch) return exactMatch;
+
+  const lowerCaseMatch = words.find(
+    (w) => w.toLowerCase() === word.toLowerCase(),
+  );
+  if (lowerCaseMatch) return lowerCaseMatch;
+
+  const mostSimilar = words
+    .map((w) => ({
+      word: w,
+      similarity: getSimilarity(w, word),
+    }))
+    .sort(higherFirst(({ similarity }) => similarity))[0];
+  assert(mostSimilar);
+
+  if (mostSimilar && mostSimilar.similarity >= 0.8) {
+    return mostSimilar.word;
+  } else {
+    return null;
+  }
+}
+
+// https://stackoverflow.com/questions/10473745/compare-strings-javascript-return-of-likely/36566052#36566052
+function getSimilarity(s1: string, s2: string): number {
+  var longer = s1;
+  var shorter = s2;
+  if (s1.length < s2.length) {
+    longer = s2;
+    shorter = s1;
+  }
+  var longerLength = longer.length;
+  if (longerLength == 0) {
+    return 1.0;
+  }
+  return (longerLength - editDistance(longer, shorter)) / longerLength;
+}
+
+function editDistance(s1: string, s2: string): number {
+  s1 = s1.toLowerCase();
+  s2 = s2.toLowerCase();
+
+  var costs = new Array();
+  for (var i = 0; i <= s1.length; i++) {
+    var lastValue = i;
+    for (var j = 0; j <= s2.length; j++) {
+      if (i == 0) costs[j] = j;
+      else {
+        if (j > 0) {
+          var newValue = costs[j - 1];
+          if (s1.charAt(i - 1) != s2.charAt(j - 1))
+            newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
+          costs[j - 1] = lastValue;
+          lastValue = newValue;
+        }
+      }
+    }
+    if (i > 0) costs[s2.length] = lastValue;
+  }
+  return costs[s2.length];
+}

package/dist/core/processing/getters/getOutDirs.ts

@@ -0,0 +1,160 @@
+export { getOutDirs, resolveOutDir }
+export type { OutDirs }
+
+import pc from "@brillout/picocolors"
+import type { ResolvedConfig, UserConfig } from "vite"
+import {
+  assertPosixPath,
+  toPosixPath,
+} from "../../files/file-system/filesystemPath.js"
+import { pathShim } from "../../files/file-system/pathShim.js"
+import { assert } from "../../gaurds/assertions/assert/index.js"
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js"
+import { createDebugger } from "../../gaurds/debugger/index.js"
+import { viteIsSSR } from "../../gaurds/validators/viteIsSSR.js"
+const debug = createDebugger("reveal:outDir")
+
+type OutDirs = {
+  /** Absolute path to `outDir` */
+  outDirRoot: string
+  /** Absolute path to `${outDir}/client` */
+  outDirClient: string
+  /** Absolute path to `${outDir}/server` */
+  outDirServer: string
+}
+
+function getOutDirs(config: ResolvedConfig): OutDirs {
+  debug("getOutDirs()", new Error().stack)
+  let outDirRoot: string
+  {
+    const outDir = getOutDirFromViteResolvedConfig(config)
+    if (isOutDirRoot(outDir)) {
+      outDirRoot = outDir
+    } else {
+      assertOutDirResolved(outDir, config)
+      assert(outDir.endsWith("/server") || outDir.endsWith("/client"))
+      assert("/client".length === "/server".length)
+      outDirRoot = outDir.slice(0, -1 * "/client".length)
+    }
+  }
+  const outDirs = getOutDirsAll(outDirRoot, config.root)
+  debug("outDirRoot", outDirRoot)
+  debug("outDirs", outDirs)
+  return outDirs
+}
+
+/** Appends `client/` or `server/` to `config.build.outDir` */
+function resolveOutDir(config: UserConfig): string {
+  debug("resolveOutDir()", new Error().stack)
+  const outDir = getOutDirFromViteUserConfig(config) || "dist"
+  debug("outDir", "outDir")
+  // outDir may already be resolved when using Telefunc + reveal (because both Telefunc and reveal use this logic)
+  if (!isOutDirRoot(outDir)) {
+    assertOutDirResolved(outDir, config)
+    return outDir
+  } else {
+    const { outDirClient, outDirServer } = determineOutDirs(outDir)
+    if (viteIsSSR(config)) {
+      debug("outDirServer", "outDirServer")
+      return outDirServer
+    } else {
+      debug("outDirClient", "outDirClient")
+      return outDirClient
+    }
+  }
+}
+
+function determineOutDirs(outDirRoot: string) {
+  assertPosixPath(outDirRoot)
+  assert(!outDirRoot.endsWith("/"))
+  assert(isOutDirRoot(outDirRoot))
+  const outDirClient = pathShim(outDirRoot, "client")
+  const outDirServer = pathShim(outDirRoot, "server")
+  assertIsNotOutDirRoot(outDirClient)
+  assertIsNotOutDirRoot(outDirServer)
+  return { outDirClient, outDirServer }
+}
+
+function getOutDirsAll(outDirRoot: string, root: string) {
+  if (!outDirIsAbsolutePath(outDirRoot)) {
+    assertPosixPath(outDirRoot)
+    assertPosixPath(root)
+    outDirRoot = pathShim(root, outDirRoot)
+  }
+
+  let { outDirClient, outDirServer } = determineOutDirs(outDirRoot)
+  outDirRoot = outDirRoot + "/"
+  outDirClient = outDirClient + "/"
+  outDirServer = outDirServer + "/"
+
+  assertNormalization(outDirRoot)
+  assertNormalization(outDirClient)
+  assertNormalization(outDirServer)
+
+  return { outDirRoot, outDirClient, outDirServer }
+}
+function assertNormalization(outDirAny: string) {
+  assertPosixPath(outDirAny)
+  assert(outDirIsAbsolutePath(outDirAny))
+  assert(outDirAny.endsWith("/"))
+  assert(!outDirAny.endsWith("//"))
+}
+
+function isOutDirRoot(outDirRot: string) {
+  const p = outDirRot.split("/").filter(Boolean)
+  const lastDir = p[p.length - 1]
+  return lastDir !== "client" && lastDir !== "server"
+}
+function assertIsNotOutDirRoot(outDir: string) {
+  assert(outDir.endsWith("/client") || outDir.endsWith("/server"))
+}
+
+/** `outDir` ends with `/server` or `/client` */
+function assertOutDirResolved(
+  outDir: string,
+  config: UserConfig | ResolvedConfig
+) {
+  assertPosixPath(outDir)
+  assertIsNotOutDirRoot(outDir)
+  assert("/client".length === "/server".length)
+  const outDirCorrected = outDir.slice(0, -1 * "/client".length)
+  const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(
+    outDirCorrected
+  )} instead.`
+  if (viteIsSSR(config)) {
+    assertUsage(outDir.endsWith("/server"), wrongUsage)
+  } else {
+    assertUsage(outDir.endsWith("/client"), wrongUsage)
+  }
+}
+
+function getOutDirFromViteUserConfig(
+  config: UserConfig | ResolvedConfig
+): string | undefined {
+  let outDir = config.build?.outDir
+  if (outDir === undefined) return undefined
+  outDir = normalize(outDir)
+  return outDir
+}
+function getOutDirFromViteResolvedConfig(config: ResolvedConfig): string {
+  let outDir = config.build.outDir
+  assert(outDir)
+  outDir = normalize(outDir)
+  return outDir
+}
+function normalize(outDir: string): string {
+  outDir = toPosixPath(outDir)
+  outDir = outDir.replace(/\/+$/, "") // remove trailing slashes
+  return outDir
+}
+
+function outDirIsAbsolutePath(outDir: string) {
+  // There doesn't seem to be a better alternative to determine whether `outDir` is an aboslute path
+  //  - Very unlikely that `outDir`'s first dir macthes the filesystem's first dir
+  //    - Although more likely to happen with Docker
+  return getFirstDir(outDir) === getFirstDir(process.cwd())
+}
+function getFirstDir(p: string) {
+  const firstDir = p.split(/\/|\\/).filter(Boolean)[0]
+  return firstDir
+}

package/dist/core/processing/getters/getPageAssets/getManifestEntry.ts

@@ -0,0 +1,164 @@
+export { getManifestEntry }
+
+import {
+  ViteManifest,
+  ViteManifestEntry,
+} from "../../../../types/interfaces/manifest.js"
+import { prependEntriesDir } from "../../../files/file-system/prependEntriesDir.js"
+import { isVirtualFileIdPageConfigValuesAll } from "../../../files/virtual-files/virtualFilePageConfigValuesAll.js"
+import {
+  assert,
+  assertIsNpmPackageImport,
+  slice,
+} from "../../../renderer/stream/utils.js"
+
+function getManifestEntry(
+  id: string,
+  assetsManifest: ViteManifest
+): { manifestKey: string; manifestEntry: ViteManifestEntry } {
+  const debugInfo = getDebugInfo(id, assetsManifest)
+
+  // Reveal client entry
+  if (id.startsWith("@@reveal/")) {
+    const manifestKeyEnd = slice(id, "@@reveal".length, 0)
+    const { manifestKey, manifestEntry } = findEntryWithKeyEnd(
+      manifestKeyEnd,
+      assetsManifest,
+      id
+    )
+    assert(manifestEntry && manifestKey, JSON.stringify(debugInfo))
+    return { manifestEntry, manifestKey }
+  }
+
+  // Page code importer
+  if (isVirtualFileIdPageConfigValuesAll(id)) {
+    {
+      const manifestKey = id
+      const manifestEntry = assetsManifest[manifestKey]
+      if (manifestEntry) {
+        return { manifestEntry, manifestKey }
+      }
+    }
+    // Workaround for what seems to be a Vite bug when process.cwd() !== config.root
+    //  - Manifest key is:
+    //       ../../virtual:reveal:pageConfigValuesAll:client:/pages/index
+    //    But it should be this instead:
+    //      virtual:reveal:pageConfigValuesAll:client:/pages/index
+    //  - This workaround was implemented to support Vitest runnung /tests/*
+    //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
+    const manifestKeyEnd = id
+    const { manifestKey, manifestEntry } = getEntryWithKeyEnd(
+      manifestKeyEnd,
+      assetsManifest,
+      id
+    )
+    assert(manifestEntry, JSON.stringify(debugInfo))
+    return { manifestEntry, manifestKey }
+  }
+
+  // User files
+  if (id.startsWith("/")) {
+    const manifestKey = id.slice(1)
+    let manifestEntry = assetsManifest[manifestKey]
+    assert(manifestEntry, JSON.stringify(debugInfo))
+    return { manifestEntry, manifestKey }
+  }
+
+  // npm package import
+  assertIsNpmPackageImport(id)
+  const found = Object.entries(assetsManifest).find(
+    ([, e]) => e.name === prependEntriesDir(id)
+  )
+  assert(found)
+  const [manifestKey, manifestEntry] = found
+  return { manifestEntry, manifestKey }
+
+  /* Can we remove this?
+  // extensions[number].pageConfigsSrcDir
+  if (id.startsWith('/node_modules/') || id.startsWith('/../')) {
+    let manifestKeyEnd = id.split('/node_modules/').slice(-1)[0]
+    assert(manifestKeyEnd, debugInfo)
+    assert(!manifestKeyEnd.startsWith('/'), debugInfo)
+    manifestKeyEnd = '/' + manifestKeyEnd
+    {
+      const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id)
+      if (manifestEntry) {
+        assert(manifestKey, debugInfo)
+        return { manifestEntry, manifestKey }
+      }
+    }
+    {
+      assert(manifestKeyEnd.startsWith('/'), debugInfo)
+      const dirS = manifestKeyEnd.split('/')
+      assert(dirS[0] === '', debugInfo)
+      manifestKeyEnd = '/' + dirS.slice(2).join('/')
+      assert(manifestKeyEnd.startsWith('/'), debugInfo)
+    }
+    {
+      const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id)
+      if (manifestEntry) {
+        assert(manifestKey, debugInfo)
+        return { manifestEntry, manifestKey }
+      }
+    }
+    assert(false, debugInfo)
+  }
+  */
+}
+
+function findEntryWithKeyEnd(
+  manifestKeyEnd: string,
+  assetsManifest: ViteManifest,
+  id: string
+) {
+  const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd)
+  assert(manifestKeyEnd.startsWith("/"), JSON.stringify(debugInfo))
+  const manifestKeys: string[] = []
+  for (const manifestKey in assetsManifest) {
+    if (manifestKey.endsWith(manifestKeyEnd)) {
+      manifestKeys.push(manifestKey)
+    }
+  }
+  const manifestKeysRelative = manifestKeys.filter((k) => k.startsWith("../"))
+  assert(manifestKeysRelative.length <= 1, JSON.stringify(debugInfo))
+  const manifestKey = manifestKeysRelative[0] ?? manifestKeys[0] ?? null
+  if (!manifestKey) {
+    return { manifestEntry: null, manifestKey: null }
+  }
+  const manifestEntry = assetsManifest[manifestKey]!
+  return { manifestEntry, manifestKey }
+}
+
+function getEntryWithKeyEnd(
+  manifestKeyEnd: string,
+  assetsManifest: ViteManifest,
+  id: string
+) {
+  const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd)
+  const manifestKeys: string[] = []
+  for (const manifestKey in assetsManifest) {
+    if (manifestKey.endsWith(manifestKeyEnd)) {
+      manifestKeys.push(manifestKey)
+    }
+  }
+  assert(manifestKeys.length <= 1, JSON.stringify(debugInfo))
+  const manifestKey = manifestKeys[0]
+  if (!manifestKey) {
+    return { manifestEntry: null, manifestKey: null }
+  }
+  const manifestEntry = assetsManifest[manifestKey]!
+  return { manifestEntry, manifestKey }
+}
+
+function getDebugInfo(
+  id: string,
+  assetsManifest: ViteManifest,
+  manifestKeyEnd?: string
+) {
+  const manifestKeys = Object.keys(assetsManifest)
+  if (manifestKeyEnd === undefined) {
+    return { manifestKeys, id }
+  } else {
+    return { manifestKeys, manifestKeyEnd, id }
+  }
+}

package/dist/core/processing/getters/getPageAssets/retrieveAssetsDev.ts

@@ -0,0 +1,96 @@
+export { retrieveAssetsDev }
+
+import type { ModuleNode, ViteDevServer } from "vite"
+import { ClientDependency } from "../../../../types/interfaces/client.js"
+import { assert, styleFileRE } from "../../../renderer/stream/utils.js"
+
+async function retrieveAssetsDev(
+  clientDependencies: ClientDependency[],
+  viteDevServer: ViteDevServer
+) {
+  const visitedModules = new Set<string>()
+  const assetUrls = new Set<string>()
+  await Promise.allSettled(
+    clientDependencies.map(async ({ id }) => {
+      if (id.startsWith("@@reveal")) return // reveal doesn't have any CSS
+      assert(id)
+      const { moduleGraph } = viteDevServer
+      const [_, graphId] = await moduleGraph.resolveUrl(id)
+      assert(graphId, id)
+      const mod = moduleGraph.getModuleById(graphId)
+      if (!mod) {
+        /* Not sure when the assertion fails. So let's just remove it for now.
+         *  - https://github.com/revealjs/reveal/issues/391
+        // `moduleGraph` is missing `.page.client.js` files on the very first render
+        assert(id.includes('.page.client.'), { id })
+        */
+        return
+      }
+      assert(mod, id)
+      collectCss(mod, assetUrls, visitedModules)
+    })
+  )
+  return Array.from(assetUrls)
+}
+
+// Collect the CSS to be injected to the HTML to avoid FLOUC
+//  - We only collect the root import: https://github.com/revealjs/reveal/issues/400
+function collectCss(
+  mod: ModuleNode,
+  styleUrls: Set<string>,
+  visitedModules: Set<string>,
+  importer?: ModuleNode
+): void {
+  assert(mod)
+  if (!mod.url) return
+  if (visitedModules.has(mod.url)) return
+  visitedModules.add(mod.url)
+  if (isStyle(mod) && (!importer || !isStyle(importer))) {
+    if (mod.url.startsWith("/")) {
+      styleUrls.add(mod.url)
+    } else if (mod.url.startsWith("\0")) {
+      // Virtual modules
+      //  - https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+      //    - I believe some Vite plugins don't respect the \0 virtual module convention. What should we do then?
+      //  - https://github.com/revealjs/reveal/issues/1327
+      //  - https://github.com/revealjs/reveal/commit/3f7b9916dddc84e29e2c20d2b0df7211b6f1acbd
+      //  - https://github.com/revealjs/reveal/issues/479#issuecomment-1870043943
+      styleUrls.add(`/@id/__x00__${mod.url.substring(1)}`)
+    } else {
+      // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
+      styleUrls.add(`/@id/${mod.url}`)
+    }
+    /* Debug:
+    logModule(mod)
+    //*/
+  }
+  mod.importedModules.forEach((dep) => {
+    collectCss(dep, styleUrls, visitedModules, mod)
+  })
+}
+
+function isStyle(mod: ModuleNode) {
+  if (
+    styleFileRE.test(mod.url) ||
+    (mod.id && /\?vue&type=style/.test(mod.id))
+  ) {
+    // `mod.type` seems broken
+    assert(mod.type === "js")
+    // logModule(mod)
+    return true
+  }
+  return false
+}
+
+/*
+function logModule(mod: ModuleNode) {
+  const redacted = 'redacted'
+  console.log({
+    ...mod,
+    ssrModule: redacted,
+    ssrTransformResult: redacted,
+    importedModules: redacted,
+    importers: redacted
+  })
+}
+//*/

package/dist/core/processing/getters/getPageAssets/retrieveAssetsProd.ts

@@ -0,0 +1,86 @@
+export { retrieveAssetsProd };
+
+import { ClientDependency } from "../../../../types/interfaces/client.js";
+import { ViteManifest } from "../../../../types/interfaces/manifest.js";
+import { assert } from "../../../renderer/stream/utils.js";
+import { getManifestEntry } from "./getManifestEntry.js";
+
+function retrieveAssetsProd(
+  clientDependencies: ClientDependency[],
+  assetsManifest: ViteManifest,
+  includeAssetsImportedByServer: boolean,
+): string[] {
+  let assetUrls = new Set<string>();
+  assert(assetsManifest);
+  const visistedAssets = new Set<string>();
+  clientDependencies.forEach(({ id, onlyAssets, eagerlyImported }) => {
+    if (eagerlyImported) return; // Eagerly imported assets aren't imported with import() and therefore don't create a new Rollup entry and aren't listed in the manifest file
+
+    const { manifestKey } = getManifestEntry(id, assetsManifest);
+    collectAssets(
+      manifestKey,
+      assetUrls,
+      visistedAssets,
+      assetsManifest,
+      onlyAssets,
+    );
+  });
+
+  collectSingleStyle(assetUrls, assetsManifest);
+
+  return Array.from(assetUrls);
+}
+
+function collectAssets(
+  manifestKey: string,
+  assetUrls: Set<string>,
+  visistedAssets: Set<string>,
+  assetsManifest: ViteManifest,
+  onlyCollectStaticAssets: boolean,
+): void {
+  if (visistedAssets.has(manifestKey)) return;
+  visistedAssets.add(manifestKey);
+
+  const manifestEntry = assetsManifest[manifestKey];
+  assert(manifestEntry, { manifestKey }.manifestKey);
+  const { file } = manifestEntry;
+  if (!onlyCollectStaticAssets) {
+    assetUrls.add(`/${file}`);
+  }
+
+  const { imports = [], assets = [], css = [] } = manifestEntry;
+
+  for (const manifestKey of imports) {
+    const importManifestEntry = assetsManifest[manifestKey];
+    assert(importManifestEntry);
+    collectAssets(
+      manifestKey,
+      assetUrls,
+      visistedAssets,
+      assetsManifest,
+      onlyCollectStaticAssets,
+    );
+  }
+
+  for (const cssAsset of css) {
+    assetUrls.add(`/${cssAsset}`);
+  }
+  for (const asset of assets) {
+    assetUrls.add(`/${asset}`);
+  }
+}
+
+// Support `config.build.cssCodeSplit: false`
+function collectSingleStyle(
+  assetUrls: Set<string>,
+  assetsManifest: ViteManifest,
+) {
+  const style = assetsManifest["style.css"];
+  if (
+    style &&
+    Object.values(assetsManifest).filter((asset) => asset.file.endsWith(".css"))
+      .length === 1
+  ) {
+    assetUrls.add(`/${style.file}`);
+  }
+}

package/dist/core/processing/getters/getPageAssets/sortPageAssetsForEarlyHintsHeader.ts

@@ -0,0 +1,40 @@
+export { sortPageAssetsForEarlyHintsHeader };
+
+import { getGlobalContext } from "../../../globals/contexts/globalContext/index.js";
+import { higherFirst } from "../../../renderer/stream/utils.js";
+import type { PageAsset } from "../getPageAssets.js";
+
+function sortPageAssetsForEarlyHintsHeader(pageAssets: PageAsset[]) {
+  const globalContext = getGlobalContext();
+  pageAssets.sort(
+    higherFirst(({ assetType }) => {
+      // In dev, we load scripts first in order to parallelize I/O and CPU
+      if (!globalContext.isProduction && assetType === "script") {
+        return 1;
+      }
+
+      let priority = 0;
+
+      // CSS has highest priority
+      if (assetType === "style") return priority;
+      priority--;
+
+      // Visual assets have high priority
+      if (assetType === "font") return priority;
+      priority--;
+      if (assetType === "image") return priority;
+      priority--;
+      if (assetType === "video") return priority;
+      priority--;
+      if (assetType === "audio") return priority;
+      priority--;
+
+      // Others
+      if (assetType !== "script") return priority;
+      priority--;
+
+      // JavaScript has lowest priority
+      return priority;
+    }),
+  );
+}