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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,374 +0,0 @@
-// 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()
-}