@revealui/core 0.0.1-pre.0

package/dist/core/gaurds/validators/isReactElement.ts

@@ -0,0 +1,21 @@
+export { isReactElement };
+
+import React, { isValidElement } from "react";
+
+function isReactElement(
+  value: ReactElement | ReactComponent,
+): value is ReactElement {
+  return isValidElement(value) || Array.isArray(value);
+}
+type ReactElement = React.ReactNode;
+type ReactComponent = () => ReactElement;
+
+// Low level implementation
+// export function isReactElement(value: unknown) {
+//   return (
+//     typeof value === "object" &&
+//     value !== null &&
+//     String((value as Record<string, unknown>)["$$typeof"]) ===
+//       "Symbol(react.element)"
+//   );
+// }

package/dist/core/gaurds/validators/isRevealApp.ts

@@ -0,0 +1,4 @@
+export function isRevealApp(): boolean {
+  const g = globalThis as Record<string, unknown>;
+  return !!g._isRevealApp;
+}

package/dist/core/gaurds/validators/isSameErrorMessage.ts

@@ -0,0 +1,8 @@
+import { isObject } from "./isObject.js";
+
+export { isSameErrorMessage };
+
+function isSameErrorMessage(err1: unknown, err2: unknown): boolean {
+  if (!isObject(err1) || !isObject(err2)) return false;
+  return err1.message === err2.message;
+}

package/dist/core/gaurds/validators/isScriptFile.ts

@@ -0,0 +1,75 @@
+import { assert } from "../assertions/assert";
+
+export {
+  isPlainJavaScriptFile,
+  isScriptFile,
+  isTemplateFile,
+  scriptFileExtensionList,
+  scriptFileExtensions,
+};
+
+// We can't use a RegExp:
+//  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
+//    - Vite's `import.meta.glob()` uses Micromatch
+//  - We need this to be a whitelist because:
+//   - A pattern `*([a-zA-Z0-9]` doesn't work.
+//     - Because of ReScript: `.res` are ReScript source files which need to be ignored. (The ReScript compiler generates `.js` files alongside `.res` files.)
+//   - Black listing doesn't work.
+//     - We cannot implement a blacklist with a glob pattern.
+//     - A post `import.meta.glob()` blacklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
+
+// prettier-ignore
+// biome-ignore format:
+const extJavaScript = [
+  'js',
+  'ts',
+  'cjs',
+  'cts',
+  'mjs',
+  'mts',
+]
+// prettier-ignore
+// biome-ignore format:
+const extJsx = [
+  'jsx',
+  'tsx',
+  'cjsx',
+  'ctsx',
+  'mjsx',
+  'mtsx',
+] as const
+// prettier-ignore
+// biome-ignore format:
+const extTemplates = [
+  'vue',
+  'svelte',
+  'marko',
+  'md',
+  'mdx'
+] as const
+const scriptFileExtensionList = [
+  ...extJavaScript,
+  ...extJsx,
+  ...extTemplates,
+] as const;
+const scriptFileExtensions: string =
+  "(" + scriptFileExtensionList.join("|") + ")";
+
+function isScriptFile(filePath: string): boolean {
+  const yes = scriptFileExtensionList.some((ext) =>
+    filePath.endsWith("." + ext),
+  );
+  if (isPlainJavaScriptFile(filePath)) assert(yes);
+  return yes;
+}
+
+function isPlainJavaScriptFile(filePath: string) {
+  const yes1 = /\.(c|m)?(j|t)s$/.test(filePath);
+  const yes2 = extJavaScript.some((ext) => filePath.endsWith("." + ext));
+  assert(yes1 === yes2);
+  return yes1;
+}
+
+function isTemplateFile(filePath: string) {
+  return extTemplates.some((ext) => filePath.endsWith("." + ext));
+}

package/dist/core/gaurds/validators/isServerSideError.ts

@@ -0,0 +1 @@
+export const isServerSideError = "_isServerSideError";

package/dist/core/gaurds/validators/isViteCliCall.ts

@@ -0,0 +1,93 @@
+export { getViteConfigFromCli, isViteCliCall }
+
+import { cac } from "cac"
+import { assert, isObject, toPosixPath } from "../../../plugins/utils.js"
+
+function isViteCliCall(): boolean {
+  let execPath = process.argv[1]
+  assert(execPath)
+  execPath = toPosixPath(execPath)
+  return (
+    // pnpm
+    execPath.endsWith("/bin/vite.js") ||
+    // npm & yarn
+    execPath.endsWith("/.bin/vite") ||
+    // Global install
+    execPath.endsWith("/bin/vite")
+  )
+}
+
+type ConfigFromCli = {
+  root: undefined | string
+  configFile: undefined | string
+} & Record<string, unknown> & {
+    build: Record<string, unknown>
+  }
+function getViteConfigFromCli(): null | ConfigFromCli {
+  if (!isViteCliCall()) return null
+
+  // Copied and adapted from https://github.com/vitejs/vite/blob/8d0a9c1ab8ddd26973509ca230b29604e872e2cd/packages/vite/src/node/cli.ts#L137-L197
+  const cli = cac("reveal:vite-simulation")
+  const desc = "FAKE_CLI"
+  cli
+    .option("-c, --config <file>", desc)
+    .option("--base <path>", desc)
+    .option("-l, --logLevel <level>", desc)
+    .option("--clearScreen", desc)
+    .option("-d, --debug [feat]", desc)
+    .option("-f, --filter <filter>", desc)
+    .option("-m, --mode <mode>", desc)
+  cli
+    .command("build [root]", desc)
+    .option("--target <target>", desc)
+    .option("--outDir <dir>", desc)
+    .option("--assetsDir <dir>", desc)
+    .option("--assetsInlineLimit <number>", desc)
+    .option("--ssr [entry]", desc)
+    .option("--sourcemap", desc)
+    .option("--minify [minifier]", desc)
+    .option("--manifest [name]", desc)
+    .option("--ssrManifest [name]", desc)
+    .option("--force", desc)
+    .option("--emptyOutDir", desc)
+    .option("-w, --watch", desc)
+    .action((root: unknown, options: unknown) => {
+      assert(isObject(options))
+      const buildOptions = cleanOptions(options)
+      assert(root === undefined || typeof root === "string")
+      assert(options.config === undefined || typeof options.config === "string")
+      configFromCli = {
+        root,
+        base: options.base,
+        mode: options.mode,
+        configFile: options.config,
+        logLevel: options.logLevel,
+        clearScreen: options.clearScreen,
+        optimizeDeps: { force: options.force },
+        build: buildOptions,
+      }
+    })
+
+  let configFromCli: ConfigFromCli | null = null
+  cli.parse()
+
+  return configFromCli
+
+  function cleanOptions(options: Record<string, unknown>) {
+    const ret = { ...options }
+    delete ret["--"]
+    delete ret.c
+    delete ret.config
+    delete ret.base
+    delete ret.l
+    delete ret.logLevel
+    delete ret.clearScreen
+    delete ret.d
+    delete ret.debug
+    delete ret.f
+    delete ret.filter
+    delete ret.m
+    delete ret.mode
+    return ret
+  }
+}

package/dist/core/gaurds/validators/isVitest.ts

@@ -0,0 +1,7 @@
+export function isVitest(): boolean {
+  return (
+    typeof process !== "undefined" &&
+    typeof process.env !== "undefined" &&
+    "VITEST" in process.env
+  );
+}

package/dist/core/gaurds/validators/rollupIsEsm.ts

@@ -0,0 +1,14 @@
+import { assert } from "../../../plugins/utils.js";
+export function rollupIsEsm(rollupOptions: { format: string }) {
+  const { format } = rollupOptions;
+  assert(typeof format === "string");
+  assert(
+    format === "amd" ||
+      format === "cjs" ||
+      format === "es" ||
+      format === "iife" ||
+      format === "system" ||
+      format === "umd",
+  );
+  return format === "es";
+}

package/dist/core/gaurds/validators/viteIsSSR.ts

@@ -0,0 +1,23 @@
+import { assert } from "../assertions/assert/index.js";
+import { isObject } from "./isObject.js";
+
+export { viteIsSSR, viteIsSSR_options };
+
+function viteIsSSR(config: { build?: { ssr?: boolean | string } }): boolean {
+  return !!config?.build?.ssr;
+}
+
+type Options = undefined | boolean | { ssr?: boolean };
+// https://github.com/vitejs/vite/discussions/5109#discussioncomment-1450726
+function viteIsSSR_options(options: Options): boolean {
+  if (options === undefined) {
+    return false;
+  }
+  if (typeof options === "boolean") {
+    return options;
+  }
+  if (isObject(options)) {
+    return !!options.ssr;
+  }
+  assert(false);
+}

package/dist/core/globals/contexts/globalContext/getPageFilesExports.ts

@@ -0,0 +1,28 @@
+import { getViteDevServer } from ".";
+import { debug } from "../../../../plugins/importUserCode/debug";
+import { virtualFileIdImportUserCodeServer } from "../../../files/virtual-files/virtualFileImportUserCode";
+import { assert } from "../../../gaurds/assertions/assert";
+import { isObject } from "../../../gaurds/validators/isObject";
+
+export { getPageFilesExports };
+
+async function getPageFilesExports(): Promise<Record<string, unknown>> {
+  const viteDevServer = getViteDevServer();
+  assert(viteDevServer);
+  let moduleExports: Record<string, unknown>;
+  try {
+    moduleExports = await viteDevServer.ssrLoadModule(
+      virtualFileIdImportUserCodeServer,
+    );
+  } catch (err) {
+    debug(
+      `Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `,
+      err,
+    );
+    throw err;
+  }
+  moduleExports = (moduleExports as any).default || moduleExports;
+  debug("Glob result: ", moduleExports);
+  assert(isObject(moduleExports));
+  return moduleExports;
+}

package/dist/core/globals/contexts/globalContext/index.ts

@@ -0,0 +1,374 @@
+// Public use
+export { getGlobalContextAsync, getGlobalContextSync }
+
+// Internal use
+export {
+  getGlobalContext,
+  getRuntimeManifest,
+  getViteConfig,
+  getViteDevServer,
+  initGlobalContext_getGlobalContextAsync,
+  initGlobalContext_renderPage,
+  initGlobalContext_runPrerender,
+  setGlobalContext_isDev,
+  setGlobalContext_isPrerendering,
+  setGlobalContext_viteConfig,
+  setGlobalContext_viteDevServer,
+}
+
+import pc from "@brillout/picocolors"
+import type { ResolvedConfig, ViteDevServer } from "vite"
+import type { ConfigRevealResolved } from "../../../../types/interfaces/reveal.js"
+
+import {
+  assertPluginManifest,
+  PluginManifest,
+} from "../../../gaurds/assertions/assertPluginManifest.js"
+import {
+  assertRuntimeManifest,
+  type RuntimeManifest,
+} from "../../../gaurds/assertions/assertRuntimeManifest.js"
+import { getConfigReveal } from "../../../processing/getters/getConfigReveal.js"
+import { setPageFiles } from "../../../processing/getters/getPageFiles/index.js"
+import { loadImportBuild } from "./loadImportBuild.js"
+
+import { ViteManifest } from "../../../../types/interfaces/manifest.js"
+import { assert } from "../../../gaurds/assertions/assert/index.js"
+import { assertNodeEnv_runtime } from "../../../gaurds/assertions/assertNodeEnv/index.js"
+import { assertUsage } from "../../../gaurds/assertions/assertUsage/index.js"
+import { assertWarning } from "../../../gaurds/assertions/assertWarning/index.js"
+import getGlobalObject from "../../../processing/getters/getGlobalObject.js"
+import { objectKeys } from "../../../processing/iterators/objectKeys.js"
+import {
+  genPromise,
+  isPlainObject,
+  objectAssign,
+} from "../../../renderer/stream/utils.js"
+import { getPageFilesExports } from "./getPageFilesExports.js"
+const globalObject = getGlobalObject<{
+  globalContext?: GlobalContext
+  viteDevServer?: ViteDevServer
+  viteDevServerPromise: Promise<ViteDevServer>
+  viteDevServerPromiseResolve: (viteDevServer: ViteDevServer) => void
+  isDev?: boolean
+  viteConfig?: ResolvedConfig
+  outDirRoot?: string
+  isPrerendering?: true
+  initGlobalContext_runPrerender_alreadyCalled?: true
+}>(
+  "globalContext.ts",
+  (() => {
+    const {
+      promise: viteDevServerPromise,
+      resolve: viteDevServerPromiseResolve,
+    } = genPromise<ViteDevServer>()
+    return {
+      viteDevServerPromise,
+      viteDevServerPromiseResolve,
+    }
+  })()
+)
+
+type GlobalContextPublic = {
+  assetsManifest: null | ViteManifest
+}
+type GlobalContext = {
+  baseServer: string
+  baseAssets: null | string
+  includeAssetsImportedByServer: boolean
+  redirects: Record<string, string>
+  trailingSlash: boolean
+  disableUrlNormalization: boolean
+} & (
+  | {
+      isProduction: false
+      isPrerendering: false
+      viteConfig: ResolvedConfig
+      viteDevServer: ViteDevServer
+      assetsManifest: null
+      pluginManifest: null
+    }
+  | ({
+      isProduction: true
+      assetsManifest: ViteManifest
+      pluginManifest: PluginManifest
+      viteDevServer: null
+    } & (
+      | {
+          isPrerendering: false
+          viteConfig: null
+        }
+      | {
+          isPrerendering: true
+          viteConfig: ResolvedConfig
+        }
+    ))
+)
+
+function getGlobalContext(): GlobalContext {
+  assert(globalObject.globalContext)
+  return globalObject.globalContext
+}
+
+/** @experimental https://reveal.dev/getGlobalContext */
+function getGlobalContextSync(): GlobalContextPublic {
+  assertUsage(
+    globalObject.globalContext,
+    "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead."
+  )
+  return makePublic(globalObject.globalContext)
+}
+/** @experimental https://reveal.dev/getGlobalContext */
+async function getGlobalContextAsync(
+  isProduction: boolean
+): Promise<GlobalContextPublic> {
+  assertUsage(
+    typeof isProduction === "boolean",
+    `[getGlobalContextAsync(isProduction)] Argument ${pc.cyan("isProduction")} ${
+      isProduction === undefined
+        ? "is missing"
+        : `should be ${pc.cyan("true")} or ${pc.cyan("false")}`
+    }`
+  )
+  await initGlobalContext_getGlobalContextAsync(isProduction)
+  const { globalContext } = globalObject
+  assert(globalContext)
+  return makePublic(globalContext)
+}
+function makePublic(globalContext: GlobalContext): GlobalContextPublic {
+  const globalContextPublic = {
+    assetsManifest: globalContext.assetsManifest,
+  }
+
+  // Add internals (and prepended _ prefix to their keys)
+  {
+    const publicKeys = Object.keys(globalContextPublic)
+    objectKeys(globalContext)
+      .filter((key) => !publicKeys.includes(key))
+      .forEach((key) => {
+        const keyPublic = `_${key}`
+        Object.defineProperty(globalContextPublic, keyPublic, {
+          enumerable: true,
+          get() {
+            assertWarning(
+              false,
+              `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`,
+              {
+                onlyOnce: true,
+              }
+            )
+            return globalContext[key]
+          },
+        })
+      })
+  }
+
+  return globalContextPublic
+}
+
+function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer) {
+  if (globalObject.viteDevServer) return
+  assertIsNotInitilizedYet()
+  assert(globalObject.viteConfig)
+  globalObject.viteDevServer = viteDevServer
+  globalObject.viteDevServerPromiseResolve(viteDevServer)
+  eagerlyLoadUserFiles()
+}
+function setGlobalContext_viteConfig(
+  viteConfig: ResolvedConfig,
+  outDirRoot: string
+): void {
+  if (globalObject.viteConfig) return
+  assertIsNotInitilizedYet()
+  globalObject.viteConfig = viteConfig
+  globalObject.outDirRoot = outDirRoot
+}
+function assertIsNotInitilizedYet() {
+  // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
+  assert(!globalObject.globalContext)
+}
+function setGlobalContext_isDev(isDev: boolean) {
+  globalObject.isDev = isDev
+}
+function setGlobalContext_isPrerendering() {
+  globalObject.isPrerendering = true
+}
+function getViteDevServer(): ViteDevServer | null {
+  return globalObject.viteDevServer ?? null
+}
+function getViteConfig(): ResolvedConfig | null {
+  return globalObject.viteConfig ?? null
+}
+
+async function initGlobalContext_renderPage(): Promise<void> {
+  await initGlobalContext(!globalObject.isDev)
+}
+
+async function initGlobalContext_runPrerender(): Promise<void> {
+  if (globalObject.initGlobalContext_runPrerender_alreadyCalled) return
+  globalObject.initGlobalContext_runPrerender_alreadyCalled = true
+
+  assert(globalObject.isPrerendering)
+  assert(globalObject.viteConfig)
+  assert(globalObject.outDirRoot)
+
+  // We assume initGlobalContext_runPrerender() to be called before:
+  // - initGlobalContext_renderPage()
+  // - initGlobalContext_getGlobalContextAsync()
+  assert(!globalObject.globalContext)
+
+  await initGlobalContext(true)
+}
+
+async function initGlobalContext_getGlobalContextAsync(
+  isProduction: boolean
+): Promise<void> {
+  if (!isProduction) {
+    const waitFor = 20
+    const timeout = setTimeout(() => {
+      assertWarning(
+        false,
+        `Vite's development server still not created after ${waitFor} seconds.`,
+        {
+          onlyOnce: false,
+          showStackTrace: true,
+        }
+      )
+    }, waitFor * 1000)
+    await globalObject.viteDevServerPromise
+    clearTimeout(timeout)
+  }
+  await initGlobalContext(isProduction)
+}
+
+async function initGlobalContext(isProduction: boolean): Promise<void> {
+  if (globalObject.globalContext) {
+    assert(globalObject.globalContext.isProduction === isProduction)
+    // We assume setGlobalContext_isPrerendering() is called before initGlobalContext()
+    assert(
+      globalObject.globalContext.isPrerendering ===
+        (globalObject.isPrerendering ?? false)
+    )
+    return
+  }
+
+  const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject
+  assertNodeEnv_runtime(isDev ?? false)
+
+  if (!isProduction) {
+    assert(viteConfig)
+    assert(viteDevServer)
+    assert(!isPrerendering)
+    const configreveal = await getConfigReveal(viteConfig)
+    const pluginManifest = getRuntimeManifest(configreveal)
+    globalObject.globalContext = {
+      isProduction: false,
+      isPrerendering: false,
+      assetsManifest: null,
+      pluginManifest: null,
+      viteDevServer,
+      viteConfig,
+      baseServer: pluginManifest.baseServer,
+      baseAssets: pluginManifest.baseAssets,
+      includeAssetsImportedByServer:
+        pluginManifest.includeAssetsImportedByServer,
+      redirects: pluginManifest.redirects,
+      trailingSlash: pluginManifest.trailingSlash,
+      disableUrlNormalization: pluginManifest.disableUrlNormalization,
+    }
+  } else {
+    const buildEntries = await loadImportBuild(globalObject.outDirRoot)
+    assertBuildEntries(buildEntries, isPrerendering ?? false)
+    const { pageFiles, assetsManifest, pluginManifest } = buildEntries
+    setPageFiles(pageFiles)
+    assertViteManifest(assetsManifest)
+    assertPluginManifest(pluginManifest)
+    const globalContext = {
+      isProduction: true as const,
+      assetsManifest,
+      pluginManifest,
+      viteDevServer: null,
+      baseServer: pluginManifest.baseServer,
+      baseAssets: pluginManifest.baseAssets,
+      includeAssetsImportedByServer:
+        pluginManifest.includeAssetsImportedByServer,
+      redirects: pluginManifest.redirects,
+      trailingSlash: pluginManifest.trailingSlash,
+      disableUrlNormalization: pluginManifest.disableUrlNormalization,
+    }
+    if (isPrerendering) {
+      assert(viteConfig)
+      const configreveal = await getConfigReveal(viteConfig)
+      assert(configreveal)
+      objectAssign(globalContext, {
+        isPrerendering: true as const,
+        viteConfig,
+      })
+      globalObject.globalContext = globalContext
+    } else {
+      objectAssign(globalContext, {
+        isPrerendering: false as const,
+        viteConfig: null,
+      })
+      globalObject.globalContext = globalContext
+    }
+  }
+}
+
+function getRuntimeManifest(
+  configreveal: ConfigRevealResolved
+): RuntimeManifest {
+  const {
+    includeAssetsImportedByServer,
+    baseServer,
+    baseAssets,
+    redirects,
+    trailingSlash,
+    disableUrlNormalization,
+  } = configreveal
+  const manifest = {
+    baseServer,
+    baseAssets,
+    includeAssetsImportedByServer,
+    redirects,
+    trailingSlash,
+    disableUrlNormalization,
+  }
+  assertRuntimeManifest(manifest)
+  return manifest
+}
+
+function assertBuildEntries<T>(
+  buildEntries: T | null,
+  isPreRendering: boolean
+): asserts buildEntries is T {
+  const errMsg = [
+    `You are tyring to run`,
+    isPreRendering ? "pre-rendering" : "the server for production",
+    `but your app isn't built yet. Run ${pc.cyan("$ vite build")} before `,
+    isPreRendering ? "pre-rendering." : "running the server.",
+  ].join(" ")
+  assertUsage(buildEntries, errMsg)
+}
+
+function assertViteManifest(
+  manifest: unknown
+): asserts manifest is ViteManifest {
+  assert(isPlainObject(manifest))
+  /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/revealjs/reveal/issues/769
+     Instead, we should rename the vite manifest e.g. with https://vitejs.dev/config/build-options.html#build-manifest
+  Object.entries(manifest)
+    // circumvent esbuild bug: esbuild adds a `default` key to JSON upon `require('./some.json')`.
+    .filter(([key]) => key !== 'default')
+    .forEach(([_, entry]) => {
+      assert(isPlainObject(entry))
+      assert(typeof entry.file === 'string')
+    })
+  */
+}
+
+function eagerlyLoadUserFiles() {
+  // Other than here, the getPageFilesExports() function is only called only upon calling the renderPage() function.
+  // We call it as early as possible here for better performance.
+  getPageFilesExports()
+}