@revealui/core 0.0.1-pre.0

package/dist/core/renderer/page/renderPageAlreadyRouted.ts

@@ -0,0 +1,373 @@
+export {
+  getPageContextInitEnhanced,
+  getRenderContext,
+  prerender404Page,
+  prerenderPage,
+  renderPageAlreadyRouted,
+}
+export type { PageContextAfterRender, PageContextInitEnhanced, RenderContext }
+
+import pc from "@brillout/picocolors"
+
+import { PageContextBuiltInServerInternal } from "../../../types/interfaces/context.js"
+import type {
+  PageConfigGlobalRuntime,
+  PageConfigRuntime,
+} from "../../../types/interfaces/page.js"
+import { assertV1Design } from "../../gaurds/assertions/assertV1Design.js"
+import { logRuntimeError } from "../../gaurds/logger/loggerRuntime.js"
+import { isNewError } from "../../gaurds/validators/isNewError.js"
+import { isServerSideError } from "../../gaurds/validators/isServerSideError.js"
+import { getGlobalContext } from "../../globals/contexts/globalContext/index.js"
+import { getErrorPageId } from "../../processing/getters/getErrorPageId.js"
+import type { Hook } from "../../processing/getters/getHook.js"
+import { GetPageAssets } from "../../processing/getters/getPageAssets.js"
+import {
+  getPageContextUrlComputed,
+  type PageContextUrlInternal,
+} from "../../processing/getters/getPageContextUrlComputed.js"
+import {
+  getPageFilesAll,
+  PageContextExports,
+} from "../../processing/getters/getPageFiles/index.js"
+import { serializePageContextClientSide } from "../../processing/serializers/serializePageContextClientSide.js"
+import { executeGuardHook } from "../../router/executeGuardHook.js"
+import { loadPageRoutes, type PageRoutes } from "../../router/loadPageRoutes.js"
+import { UrlPublic } from "../../targets/url/index.js"
+
+import { PageFile } from "../../__internal/index.js"
+import {
+  createHttpResponsePage,
+  createHttpResponsePageContextJson,
+  HttpResponse,
+} from "../../targets/http/createHttpResponse.js"
+import { getHtmlString } from "../stream/html.js"
+import {
+  assert,
+  assertUsage,
+  assertWarning,
+  hasProp,
+  normalizeHeaders,
+  objectAssign,
+} from "../stream/utils.js"
+import { executeOnBeforeRenderAndDataHooks } from "./executeOnBeforeRenderAndDataHooks.js"
+import { executeOnRenderHtmlHook } from "./executeOnRenderHtmlHook.js"
+import {
+  loadUserFilesServerSide,
+  PageContext_loadUserFilesServerSide,
+  type PageFiles,
+} from "./loadUserFilesServerSide.js"
+import {
+  PageContextForUserConsumptionServerSide,
+  preparePageContextForUserConsumptionServerSide,
+} from "./preparePageContextForUserConsumptionServerSide.js"
+
+type PageContextAfterRender = {
+  httpResponse: HttpResponse
+  errorWhileRendering: null | Error
+}
+type URLType = {
+  urlOriginal: string
+  url: string
+  urlPathname: string
+  urlParsed: UrlPublic
+  _pageConfigs: PageConfigRuntime[]
+  pageId: string
+  _passToClient: Record<string, unknown>
+  _pageContextInit: Record<string, unknown>
+  __getPageAssets: GetPageAssets
+  _isHtmlOnly: boolean
+  _baseServer: string
+  _pageFilePathsLoaded: string[]
+  _httpRequestId: number | null
+}
+async function renderPageAlreadyRouted<
+  PageContext extends {
+    pageId: string
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true
+    is404: null | boolean
+    routeParams: Record<string, string>
+    errorWhileRendering: null | Error
+    _httpRequestId: number
+  } & PageContextInitEnhanced &
+    PageContextUrlInternal &
+    PageContext_loadUserFilesServerSide,
+>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender> {
+  // pageContext.pageId can either be the:
+  //  - ID of the page matching the routing, or the
+  //  - ID of the error page `_error.page.js`.
+  assert(hasProp(pageContext, "pageId", "string"))
+
+  const isError: boolean =
+    pageContext.is404 || !!pageContext.errorWhileRendering
+  assert(
+    isError ===
+      (pageContext.pageId ===
+        getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs))
+  )
+
+  objectAssign(pageContext, await loadUserFilesServerSide(pageContext))
+
+  if (!isError) {
+    await executeGuardHook(pageContext, (context) =>
+      preparePageContextForUserConsumptionServerSide(
+        context as unknown as PageContextForUserConsumptionServerSide
+      )
+    )
+  }
+
+  if (!isError) {
+    await executeOnBeforeRenderAndDataHooks(
+      pageContext as unknown as PageContextForUserConsumptionServerSide
+    )
+  } else {
+    try {
+      await executeOnBeforeRenderAndDataHooks(
+        pageContext as unknown as {
+          pageId: string
+          _pageConfigs: PageConfigRuntime[]
+          _pageContextAlreadyProvidedByOnPrerenderHook?: true
+        } & PageContextExports &
+          PageContextBuiltInServerInternal & { [key: string]: unknown }
+      )
+    } catch (err) {
+      if (isNewError(err, pageContext.errorWhileRendering)) {
+        logRuntimeError(err, pageContext._httpRequestId)
+      }
+    }
+  }
+
+  if (pageContext.isClientSideNavigation) {
+    if (isError) {
+      objectAssign(pageContext, { [isServerSideError]: true })
+    }
+    const pageContextSerialized: string =
+      serializePageContextClientSide(pageContext)
+    const httpResponse = await createHttpResponsePageContextJson(
+      pageContextSerialized
+    )
+    objectAssign(pageContext, { httpResponse })
+    return pageContext
+  }
+
+  const renderHookResult = await executeOnRenderHtmlHook(
+    pageContext as unknown as PageContextBuiltInServerInternal &
+      PageContextExports &
+      Omit<URLType, "_passToClient" | "_pageContextInit"> & {
+        _passToClient: string[]
+        _pageContextInit: Record<string, unknown>
+      }
+  )
+
+  const { htmlRender, renderHook } = renderHookResult
+  const httpResponse = await createHttpResponsePage(
+    htmlRender,
+    renderHook,
+    pageContext
+  )
+  objectAssign(pageContext, { httpResponse })
+  return pageContext
+}
+
+async function prerenderPage(
+  pageContext: PageContextInitEnhanced &
+    PageFiles & {
+      routeParams: Record<string, string>
+      pageId: string
+      _urlRewrite: null
+      _httpRequestId: number | null
+      _usesClientRouter: boolean
+      _pageContextAlreadyProvidedByOnPrerenderHook?: true
+      is404: null | boolean
+    }
+) {
+  objectAssign(pageContext, {
+    isClientSideNavigation: false,
+    _urlHandler: null,
+  })
+
+  // Define a type assertion or conversion to ensure compatibility with the expected type
+  const compatiblePageContext = {
+    ...pageContext,
+    config: {
+      ...(pageContext as any).config,
+    },
+    configEntries: (pageContext as any).configEntries || {},
+  } as unknown as PageContextBuiltInServerInternal & {
+    pageId: string
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true
+    _pageConfigs: PageConfigRuntime[]
+    config: Record<string, unknown>
+    _passToClient: string[]
+    _pageContextInit: Record<string, unknown>
+    __getPageAssets: GetPageAssets
+    _isHtmlOnly: boolean
+    _baseServer: string
+    _pageFilePathsLoaded: string[]
+    _httpRequestId: number | null
+    configEntries: Array<[string, unknown]>
+  }
+
+  compatiblePageContext.configEntries = (pageContext as any).configEntries || {}
+
+  await executeOnBeforeRenderAndDataHooks(compatiblePageContext)
+
+  const { htmlRender, renderHook } = await executeOnRenderHtmlHook(
+    compatiblePageContext
+  )
+  assertUsage(
+    htmlRender !== null,
+    `Cannot pre-render ${pc.cyan(compatiblePageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${
+      renderHook.hookFilePath
+    } didn't return an HTML string.`
+  )
+  assert(pageContext.isClientSideNavigation === false)
+  const documentHtml = await getHtmlString(htmlRender)
+  assert(typeof documentHtml === "string")
+  if (!pageContext._usesClientRouter) {
+    return { documentHtml, pageContextSerialized: null, pageContext }
+  } else {
+    const pageContextSerialized = serializePageContextClientSide(pageContext)
+    return { documentHtml, pageContextSerialized, pageContext }
+  }
+}
+
+async function prerender404Page(
+  renderContext: RenderContext,
+  pageContextInit_: Record<string, unknown> | null
+) {
+  const errorPageId = getErrorPageId(
+    renderContext.pageFilesAll,
+    renderContext.pageConfigs
+  )
+  if (!errorPageId) {
+    return null
+  }
+
+  const pageContext = {
+    pageId: errorPageId,
+    _httpRequestId: null,
+    _urlRewrite: null,
+    is404: true,
+    routeParams: {},
+    // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
+    _usesClientRouter: false,
+    _debugRouteMatches: [],
+  }
+
+  const pageContextInit = {
+    urlOriginal: "/fake-404-url", // A URL is needed for `applyViteHtmlTransform`
+  }
+  objectAssign(pageContextInit, pageContextInit_)
+  {
+    const pageContextInitEnhanced = getPageContextInitEnhanced(
+      pageContextInit,
+      renderContext
+    )
+    objectAssign(pageContext, pageContextInitEnhanced)
+  }
+
+  objectAssign(pageContext, await loadUserFilesServerSide(pageContext))
+
+  return prerenderPage(pageContext)
+}
+
+type PageContextInitEnhanced = ReturnType<typeof getPageContextInitEnhanced>
+function getPageContextInitEnhanced(
+  pageContextInit: {
+    urlOriginal: string
+    headersOriginal?: unknown
+  },
+  renderContext: RenderContext,
+  {
+    ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+      urlRewrite: null,
+      urlHandler: null,
+      isClientSideNavigation: false,
+    },
+  }: {
+    ssr?: {
+      urlRewrite: null | string
+      urlHandler: null | ((url: string) => string)
+      isClientSideNavigation: boolean
+    }
+  } = {}
+) {
+  assert(pageContextInit.urlOriginal)
+
+  const globalContext = getGlobalContext()
+  const pageContextInitEnhanced = {}
+  objectAssign(pageContextInitEnhanced, pageContextInit)
+  objectAssign(pageContextInitEnhanced, {
+    _objectCreatedByreveal: true,
+    // The following is defined on `pageContext` because we can eventually make these non-global (e.g. sot that two pages can have different includeAssetsImportedByServer settings)
+    _baseServer: globalContext.baseServer,
+    _baseAssets: globalContext.baseAssets,
+    _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
+    // TODO: use GloablContext instead
+    _pageFilesAll: renderContext.pageFilesAll,
+    _pageConfigs: renderContext.pageConfigs,
+    _pageConfigGlobal: renderContext.pageConfigGlobal,
+    _allPageIds: renderContext.allPageIds,
+    _pageRoutes: renderContext.pageRoutes,
+    _onBeforeRouteHook: renderContext.onBeforeRouteHook,
+    _pageContextInit: pageContextInit,
+    _urlRewrite: urlRewrite,
+    _urlHandler: urlHandler,
+    isClientSideNavigation,
+  })
+
+  // pageContext.urlParsed
+  const pageContextUrlComputed = getPageContextUrlComputed(
+    pageContextInitEnhanced
+  )
+  objectAssign(pageContextInitEnhanced, pageContextUrlComputed)
+
+  // pageContext.headers
+  {
+    let headers: null | Record<string, string>
+    if (pageContextInit.headersOriginal) {
+      headers = normalizeHeaders(pageContextInit.headersOriginal)
+    } else {
+      headers = null
+    }
+    objectAssign(pageContextInitEnhanced, { headers })
+  }
+
+  return pageContextInitEnhanced
+}
+
+type RenderContext = {
+  pageFilesAll: PageFile[]
+  pageConfigs: PageConfigRuntime[]
+  pageConfigGlobal: PageConfigGlobalRuntime
+  allPageIds: string[]
+  pageRoutes: PageRoutes
+  onBeforeRouteHook: Hook | null
+}
+// TODO: remove getRenderContext() in favor of getGlobalObject() + reloadGlobalContext()
+// TODO: impl GlobalNodeContext + GlobalClientContext + GloablContext, and use GlobalContext instead of RenderContext
+async function getRenderContext(): Promise<RenderContext> {
+  const globalContext = getGlobalContext()
+  const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } =
+    await getPageFilesAll(false, globalContext.isProduction)
+  const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(
+    pageConfigs,
+    pageConfigGlobal,
+    allPageIds
+  )
+  assertV1Design(
+    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
+    pageConfigs.length > 0,
+    pageFilesAll
+  )
+  const renderContext = {
+    pageFilesAll: pageFilesAll,
+    pageConfigs,
+    pageConfigGlobal,
+    allPageIds: allPageIds,
+    pageRoutes,
+    onBeforeRouteHook,
+  }
+  return renderContext
+}

package/dist/core/renderer/page/resolveRedirects.ts

@@ -0,0 +1,75 @@
+export { resolveRedirects }
+
+// For ./resolveRedirects.spec.ts
+export { resolveRouteStringRedirect }
+
+import pc from "@brillout/picocolors"
+
+import { assert } from "../../gaurds/assertions/assert/index.js"
+import { assertIsNotBrowser } from "../../gaurds/assertions/assertIsNotBrowser/index.js"
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js"
+import {
+  assertRouteString,
+  resolveRouteString,
+} from "../../router/resolveRouteString.js"
+import { resolveUrlPathname } from "../../router/resolveUrlPathname.js"
+import {
+  assertUsageUrlRedirectTarget,
+  isUrlRedirectTarget,
+} from "../../targets/url/parseUrl.js"
+
+assertIsNotBrowser() // Don't bloat the client
+
+// TODO/next-major-release: update
+const configSrc = "[vite.config.js > reveal({ redirects })]"
+
+function resolveRedirects(
+  redirects: Record<string, string>,
+  urlPathname: string
+): null | string {
+  for (const [urlSource, urlTarget] of Object.entries(redirects)) {
+    const urlResolved = resolveRouteStringRedirect(
+      urlSource,
+      urlTarget,
+      urlPathname
+    )
+    if (urlResolved) return urlResolved
+  }
+  return null
+}
+
+function resolveRouteStringRedirect(
+  urlSource: string,
+  urlTarget: string,
+  urlPathname: string
+): null | string {
+  assertRouteString(urlSource, `${configSrc} Invalid`)
+  // Is allowing any protocol a safety issue? https://github.com/revealjs/reveal/pull/1292#issuecomment-1828043917
+  assertUsageUrlRedirectTarget(
+    urlTarget,
+    `${configSrc} The URL redirection target`,
+    true
+  )
+  assertParams(urlSource, urlTarget)
+  const match = resolveRouteString(urlSource, urlPathname)
+  if (!match) return null
+  const urlResolved = resolveUrlPathname(urlTarget, match.routeParams)
+  if (urlResolved === urlPathname) return null
+  assert(isUrlRedirectTarget(urlResolved))
+  return urlResolved
+}
+
+function assertParams(urlSource: string, urlTarget: string) {
+  const routeSegments = urlTarget.split("/")
+  routeSegments.forEach((routeSegment) => {
+    if (routeSegment.startsWith("@") || routeSegment.startsWith("*")) {
+      const segments = urlSource.split("/")
+      assertUsage(
+        segments.includes(routeSegment),
+        `${configSrc} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(
+          routeSegment
+        )} used by the redirection target URL ${pc.string(urlTarget)}`
+      )
+    }
+  })
+}

package/dist/core/renderer/prerender/index.ts

@@ -0,0 +1 @@
+export { runPrerenderFromAPI as prerender } from "./runPrerender.js";