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

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

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

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

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