@revealui/core 0.0.1-pre.0

package/dist/core/targets/client/router.ts

@@ -0,0 +1,15 @@
+import { assertWarning } from "../../gaurds/assertions/assertWarning";
+
+export { navigate, prefetch, reload };
+
+// `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
+const navigate: never = (() => warnNoEffect("navigate")) as never;
+const reload: never = (() => warnNoEffect("reload")) as never;
+const prefetch: never = (() => warnNoEffect("prefetch")) as never;
+
+function warnNoEffect(caller: string) {
+  assertWarning(false, `Calling ${caller}() on the server-side has no effect`, {
+    showStackTrace: true,
+    onlyOnce: false,
+  });
+}

package/dist/core/targets/client/scrollRestoration.ts

@@ -0,0 +1,37 @@
+// Handle the browser's native scroll restoration mechanism
+
+export { browserNativeScrollRestoration_disable };
+export { setupNativeScrollRestoration };
+export { setInitialRenderIsDone };
+
+import getGlobalObject from "../../processing/getters/getGlobalObject.js";
+import { onPageHide, onPageShow } from "./utils.js";
+
+const globalObject = getGlobalObject<{
+  initialRenderIsDone?: true;
+}>("scrollRestoration.ts", {});
+
+// We use the browser's native scroll restoration mechanism only for the first render
+function setupNativeScrollRestoration() {
+  browserNativeScrollRestoration_enable();
+  onPageHide(browserNativeScrollRestoration_enable);
+  onPageShow(
+    () =>
+      globalObject.initialRenderIsDone &&
+      browserNativeScrollRestoration_disable(),
+  );
+}
+function setInitialRenderIsDone() {
+  globalObject.initialRenderIsDone = true;
+}
+
+function browserNativeScrollRestoration_disable() {
+  if ("scrollRestoration" in window.history) {
+    window.history.scrollRestoration = "manual";
+  }
+}
+function browserNativeScrollRestoration_enable() {
+  if ("scrollRestoration" in window.history) {
+    window.history.scrollRestoration = "auto";
+  }
+}

package/dist/core/targets/client/setScrollPosition.ts

@@ -0,0 +1,87 @@
+export { autoSaveScrollPosition, setScrollPosition }
+export type { ScrollTarget }
+
+import { saveScrollPosition, type ScrollPosition } from "./history.js"
+import { assert, onPageHide, sleep, throttle } from "./utils.js"
+
+type ScrollTarget = undefined | { preserveScroll: boolean } | ScrollPosition
+function setScrollPosition(scrollTarget: ScrollTarget): void {
+  if (scrollTarget && "x" in scrollTarget) {
+    setScroll(scrollTarget)
+    return
+  }
+  if (scrollTarget?.preserveScroll) {
+    return
+  }
+  scrollToTopOrHash()
+}
+
+// Replicates the browser's native behavior
+function scrollToTopOrHash() {
+  const hash = getUrlHash()
+  if (!hash || hash === "top") {
+    setScroll({ x: 0, y: 0 })
+  } else {
+    const hashTarget =
+      document.getElementById(hash) || document.getElementsByName(hash)[0]
+    if (hashTarget) {
+      hashTarget.scrollIntoView()
+    }
+  }
+}
+
+/** Change the browser's scoll position, in a way that works during a repaint. */
+function setScroll(scrollPosition: ScrollPosition) {
+  const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y)
+  const done = () =>
+    window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y
+
+  // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+  if (done()) return
+
+  scroll()
+
+  // Because `done()` doesn't seem to always force the repaint to be finished, we potentially need to retry again.
+  if (done()) return
+  requestAnimationFrame(() => {
+    scroll()
+    if (done()) return
+
+    setTimeout(async () => {
+      scroll()
+      if (done()) return
+
+      // In principle, `requestAnimationFrame() -> setTimeout(, 0)` should be enough.
+      //  - https://stackoverflow.com/questions/61281139/waiting-for-repaint-in-javascript
+      //  - But it's not enough for `Firefox 97.0.1`.
+      //  - The following strategy is very agressive. It doesn't need to be that aggressive for Firefox. But we do it to be safe.
+      const start = new Date().getTime()
+      while (true) {
+        await sleep(10)
+        scroll()
+        if (done()) return
+        const millisecondsElapsed = new Date().getTime() - start
+        if (millisecondsElapsed > 100) return
+      }
+    }, 0)
+  })
+}
+
+function getUrlHash(): string | null {
+  let { hash } = window.location
+  if (hash === "") return null
+  assert(hash.startsWith("#"))
+  hash = hash.slice(1)
+  return hash
+}
+
+// Save scroll position (needed for back-/forward navigation)
+function autoSaveScrollPosition() {
+  // Safari cannot handle more than 100 `history.replaceState()` calls within 30 seconds (https://github.com/revealjs/reveal/issues/46)
+  window.addEventListener(
+    "scroll",
+    throttle(saveScrollPosition, Math.ceil(1000 / 3)),
+    { passive: true }
+  )
+  onPageHide(saveScrollPosition)
+}

package/dist/core/targets/client/skipLink.ts

@@ -0,0 +1,63 @@
+export { skipLink };
+
+import { globalObject } from "../../globals/objects/index.js";
+import { getBaseServer } from "../../processing/getters/getBaseServer.js";
+import {
+  assert,
+  isBaseServer,
+  isUrl,
+  isUrlExternal,
+  parseUrl,
+} from "./utils.js";
+
+function skipLink(linkTag: HTMLElement): boolean {
+  const url = linkTag.getAttribute("href");
+  return (
+    url === null ||
+    !isUrl(url) ||
+    url === "" ||
+    isUrlExternal(url) ||
+    isHashUrl(url) ||
+    isNewTabLink(linkTag) ||
+    !hasBaseServer(url) ||
+    // Purposely last because disableAutomaticLinkInterception will be removed in the next major release
+    !isDisableAutomaticLinkInterception()
+  );
+}
+
+function isNewTabLink(linkTag: HTMLElement) {
+  const target = linkTag.getAttribute("target");
+  const rel = linkTag.getAttribute("rel");
+  return (
+    target === "_blank" ||
+    target === "_external" ||
+    rel === "external" ||
+    linkTag.hasAttribute("download")
+  );
+}
+function isHashUrl(url: string) {
+  if (url.startsWith("#")) {
+    return true;
+  }
+  const removeHash = (url: string) => url.split("#")[0];
+  if (
+    url.includes("#") &&
+    removeHash(url) === removeHash(window.location.pathname)
+  ) {
+    return true;
+  }
+  return false;
+}
+function hasBaseServer(url: string): boolean {
+  const baseServer = getBaseServer();
+  assert(isBaseServer(baseServer));
+  const { hasBaseServer } = parseUrl(url, baseServer);
+  return hasBaseServer;
+}
+
+function isDisableAutomaticLinkInterception(): boolean {
+  // @ts-ignore
+  // return !!window._disableAutomaticLinkInterception;
+  /* globalObject should be used if we want to make disableAutomaticLinkInterception a page-by-page setting  */
+  return globalObject.disableAutomaticLinkInterception ?? false;
+}

package/dist/core/targets/client/utils.ts

@@ -0,0 +1,34 @@
+// Utils needed by Client Routing.
+
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from "./onLoad.js";
+onLoad();
+
+// We load the Server Routing utils: we tolerate the tiny amount of code that is only needed by Server Routing (only 1-2 lines).
+// We re-export some of the utils down below only to list the utils needed by Client Routing.
+export * from "../server/utils.js";
+
+// export * from "../utils/assertSingleInstance.js"
+export * from "../../gaurds/validators/isCallable.js";
+export * from "../../dom/onPageVisibilityChange.js";
+export * from "../../gaurds/assertions/assertType.js";
+export * from "../../gaurds/validators/hasProp.js";
+export * from "../../gaurds/validators/isBrowser.js";
+export * from "../../gaurds/validators/isObject.js";
+export * from "../../gaurds/validators/isPlainObject.js";
+export * from "../../gaurds/validators/isReact.js";
+export * from "../../gaurds/validators/isSameErrorMessage.js";
+export * from "../../globals/versions/PROJECT_VERSION.js";
+export * from "../../hooks/executeHook.js";
+export * from "../../targets/url/parseUrl.js";
+export * from "../../utils/array/slice.js";
+export * from "../../gaurds/assertions/assert/index.js";
+export * from "../../gaurds/assertions/assertRoutingType/index.js";
+export * from "../../utils/async/genPromise.js";
+export * from "../../utils/async/sleep.js";
+export * from "../../utils/async/throttle.js";
+export * from "../../processing/getters/getCurrentUrl.js";
+export * from "../../processing/getters/getGlobalObject.js";
+export * from "../../utils/object/objectAssign.js";
+export * from "../../../types/interfaces/logic.js";
+export * from "../url/redirectHard.js";

package/dist/core/targets/http/createHttpResponse.ts

@@ -0,0 +1,254 @@
+export {
+  createHttpResponseError,
+  createHttpResponseFavicon404,
+  createHttpResponsePage,
+  createHttpResponsePageContextJson,
+  createHttpResponseRedirect,
+}
+export type { HttpResponse }
+
+import { Readable } from "stream"
+import { PageConfigRuntime } from "../../../types/interfaces/page.js"
+import { assert } from "../../gaurds/assertions/assert/index.js"
+import { assertNoInfiniteHttpRedirect } from "../../gaurds/assertions/assertNoInfiniteHttpRedirect.js"
+import { isErrorPage } from "../../gaurds/validators/isErrorPage.js"
+import { getCacheControl } from "../../processing/getters/getCacheControl.js"
+import {
+  getEarlyHints,
+  type EarlyHint,
+} from "../../processing/getters/getEarlyHints.js"
+import { getErrorPageId } from "../../processing/getters/getErrorPageId.js"
+import {
+  getHttpResponseBody,
+  getHttpResponseBodyStreamHandlers,
+  HttpResponseBody,
+} from "../../processing/getters/getHttpResponseBody.js"
+import type { GetPageAssets } from "../../processing/getters/getPageAssets.js"
+import { RenderHook } from "../../renderer/page/executeOnRenderHtmlHook.js"
+import { HtmlRender } from "../../renderer/stream/html.js"
+import type {
+  AbortStatusCode,
+  RedirectStatusCode,
+  UrlRedirect,
+} from "../../router/abort.js"
+import {PageFile} from "../../__internal/index.js"
+
+type HttpResponse = {
+  statusCode: 200 | 404 | 500 | RedirectStatusCode | AbortStatusCode
+  headers: [string, string][]
+  earlyHints: EarlyHint[]
+  contentType: "application/json" | "text/html;charset=utf-8"
+} & HttpResponseBody
+
+// Trick to improve TypeScript DX
+type StatusCode = HttpResponse["statusCode"]
+type ContentType = HttpResponse["contentType"]
+type ResponseHeaders = HttpResponse["headers"]
+
+async function createHttpResponsePage(
+  htmlRender: HtmlRender,
+  renderHook: null | RenderHook,
+  pageContext: {
+    pageId: null | string
+    is404: null | boolean
+    errorWhileRendering: null | Error
+    __getPageAssets: GetPageAssets
+    _pageConfigs: PageConfigRuntime[]
+    abortStatusCode?: AbortStatusCode
+  }
+): Promise<HttpResponse> {
+  let statusCode: StatusCode | undefined = pageContext.abortStatusCode
+  if (!statusCode) {
+    const isError =
+      !pageContext.pageId ||
+      isErrorPage(pageContext.pageId, pageContext._pageConfigs)
+    if (pageContext.errorWhileRendering) {
+      assert(isError)
+    }
+    if (!isError) {
+      assert(pageContext.is404 === null)
+      statusCode = 200
+    } else {
+      assert(pageContext.is404 === true || pageContext.is404 === false)
+      statusCode = pageContext.is404 ? 404 : 500
+    }
+  }
+
+  const earlyHints = getEarlyHints(await pageContext.__getPageAssets())
+
+  const headers: ResponseHeaders = []
+  assert(pageContext.pageId)
+  const cacheControl = getCacheControl(
+    pageContext.pageId,
+    pageContext._pageConfigs
+  )
+  if (cacheControl) {
+    headers.push(["Cache-Control", cacheControl])
+  }
+
+  return await createHttpResponse(
+    statusCode,
+    "text/html;charset=utf-8",
+    headers,
+    htmlRender,
+    earlyHints,
+    renderHook
+  )
+}
+
+function createHttpResponseFavicon404(): Promise<HttpResponse> {
+  const httpResponse = createHttpResponse(
+    404,
+    "text/html;charset=utf-8",
+    [],
+    "<p>No favicon.ico found.</p><script>console.log('This HTTP response was generated by reveal.')</script>"
+  )
+  return Promise.resolve(httpResponse)
+}
+
+async function createHttpResponseError(
+  pageContext: null | {
+    _pageFilesAll: PageFile[]
+    _pageConfigs: PageConfigRuntime[]
+  }
+): Promise<HttpResponse> {
+  const reason: string = (() => {
+    if (!pageContext) {
+      return "no error page (https://reveal.dev/error-page) could be rendered"
+    }
+    const errorPageId = getErrorPageId(
+      pageContext._pageFilesAll,
+      pageContext._pageConfigs
+    )
+    if (errorPageId) {
+      return "the error page (https://reveal.dev/error-page) couldn't be rendered (for example if an error occurred while rendering the error page)"
+    } else {
+      return "no error page (https://reveal.dev/error-page) is defined, make sure to create one"
+    }
+  })()
+  const httpResponse = createHttpResponse(
+    500,
+    "text/html;charset=utf-8",
+    [],
+    `<p>An error occurred.</p><script>console.log(${JSON.stringify(
+      `This HTTP response was generated by reveal. reveal returned this response because ${reason}.`
+    )})</script>`
+  )
+  return httpResponse
+}
+
+async function createHttpResponsePageContextJson(
+  pageContextSerialized: string
+) {
+  const httpResponse = createHttpResponse(
+    200,
+    "application/json",
+    [],
+    pageContextSerialized,
+    [],
+    null
+  )
+  return httpResponse
+}
+
+async function createHttpResponseRedirect(
+  { url, statusCode }: UrlRedirect,
+  // The URL we assume the redirect to be logically based on
+  urlLogical: string
+): Promise<HttpResponse> {
+  assertNoInfiniteHttpRedirect(url, urlLogical)
+  assert(url)
+  assert(statusCode)
+  assert(300 <= statusCode && statusCode <= 399)
+  const headers: ResponseHeaders = [["Location", url]]
+  return createHttpResponse(
+    statusCode,
+    "text/html;charset=utf-8",
+    headers,
+    // For bots / programmatic crawlig: show what's going on.
+    // For users: showing a blank page is probably better than a flickering text.
+    `<p style="display: none">Redirecting to ${url}</p><script>console.log('This HTTP response was generated by reveal.')</script>`
+  )
+}
+
+async function createHttpResponse(
+  statusCode: StatusCode,
+  contentType: ContentType,
+  headers: ResponseHeaders,
+  htmlRender: HtmlRender,
+  earlyHints: EarlyHint[] = [],
+  renderHook: null | RenderHook = null
+): Promise<HttpResponse> {
+  headers.push(["Content-Type", contentType])
+
+  assert(renderHook || typeof htmlRender === "string")
+
+  interface HttpResponse {
+    statusCode: StatusCode
+    headers: ResponseHeaders
+    contentType: ContentType
+    earlyHints: EarlyHint[]
+    body: string
+    pipe: (res: any) => void
+    getReadableNodeStream: () => Promise<Readable>
+    getReadableWebStream: () => ReadableStream
+    getBody: () => Promise<string>
+  }
+
+  return {
+    statusCode: statusCode as StatusCode,
+    headers: headers as ResponseHeaders,
+    contentType: contentType as ContentType,
+    earlyHints: earlyHints as EarlyHint[],
+    body:
+      typeof htmlRender === "string"
+        ? htmlRender
+        : await getHttpResponseBody(htmlRender, renderHook),
+    pipe: getHttpResponseBodyStreamHandlers(htmlRender, renderHook).pipe,
+    getReadableNodeStream: async (): Promise<Readable> => {
+      const stream = await getHttpResponseBodyStreamHandlers(
+        htmlRender,
+        renderHook
+      ).getReadableNodeStream()
+      if (!(stream instanceof Readable)) {
+        throw new Error(
+          "Expected getReadableNodeStream to return a Readable stream, but received a different type."
+        )
+      }
+      return stream as Readable
+    },
+    getReadableWebStream(): ReadableStream<Uint8Array> {
+      const stream = getHttpResponseBodyStreamHandlers(
+        htmlRender,
+        renderHook
+      ).getReadableWebStream()
+      if (!stream) {
+        throw new Error(
+          "Expected getReadableWebStream to return a Readable stream, but received null."
+        )
+      }
+      return stream
+    },
+    async getBody(): Promise<string> {
+      const responseBody = await getHttpResponseBody(htmlRender, renderHook)
+      if (typeof responseBody === "string") {
+        return responseBody
+      } else if (
+        responseBody &&
+        typeof (responseBody as { getBody: () => string }).getBody ===
+          "function"
+      ) {
+        if (
+          typeof (responseBody as { getBody: () => string }).getBody ===
+          "function"
+        ) {
+          return (responseBody as { getBody: () => string }).getBody()
+        } else {
+          throw new Error("Expected responseBody to have a getBody method.")
+        }
+      } else {
+        throw new Error("Expected responseBody to have a getBody method.")
+      }
+    },
+  } as HttpResponse
+}

package/dist/core/targets/http/fetchBanner.ts

@@ -0,0 +1,25 @@
+const fetchBanner = async () => {
+  try {
+    const response = await fetch(
+      `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/banners`,
+      {
+        method: "GET",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch banner:", error);
+    return [];
+  }
+};
+
+export default fetchBanner;

package/dist/core/targets/http/fetchCard.ts

@@ -0,0 +1,25 @@
+const fetchCard = async () => {
+  try {
+    const response = await fetch(
+      `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/cards`,
+      {
+        method: "GET",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch cards:", error);
+    return [];
+  }
+};
+
+export default fetchCard;

package/dist/core/targets/http/fetchEvents.ts

@@ -0,0 +1,25 @@
+const fetchEvents = async () => {
+  try {
+    const response = await fetch(
+      `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/events`,
+      {
+        method: "GET",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch events:", error);
+    return [];
+  }
+};
+
+export default fetchEvents;

package/dist/core/targets/http/fetchHero.ts

@@ -0,0 +1,25 @@
+const fetchHero = async () => {
+  try {
+    const response = await fetch(
+      `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/heros`,
+      {
+        method: "GET",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch hero:", error);
+    return [];
+  }
+};
+
+export default fetchHero;

package/dist/core/targets/http/fetchMainInfos.ts

@@ -0,0 +1,25 @@
+const fetchMainInfos = async () => {
+  try {
+    const response = await fetch(
+      `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/info`,
+      {
+        method: "GET",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch videos:", error);
+    return [];
+  }
+};
+
+export default fetchMainInfos;