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

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

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

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

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

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

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

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

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

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

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

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

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