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

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

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

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

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

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

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

@@ -1,40 +0,0 @@
-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;
-    }),
-  );
-}