@revealui/core 0.0.1-pre.0

package/dist/core/globals/contexts/globalContext/loadImportBuild.ts

@@ -0,0 +1,44 @@
+export { loadImportBuild, setImportBuildGetters };
+
+// @ts-ignore - Type declarations may not be available for this package
+import { importServerEntry } from "@brillout/vite-plugin-server-entry/runtime";
+import { assert } from "../../../gaurds/assertions/assert";
+
+const buildGetters = (globalThis.__reveal_buildGetters =
+  globalThis.__reveal_buildGetters || {
+    getters: null,
+  });
+
+type BuildGetters = null | {
+  pageFiles: () => Promise<Record<string, unknown>>;
+  getAssetsManifest: () => Promise<Record<string, unknown>>;
+  pluginManifest: () => Promise<Record<string, unknown>>;
+};
+
+function setImportBuildGetters(getters: BuildGetters) {
+  buildGetters.getters = getters;
+}
+
+async function loadImportBuild(outDir?: string) {
+  if (!buildGetters.getters) {
+    await importServerEntry(outDir);
+    assert(buildGetters.getters);
+  }
+
+  const [pageFiles, assetsManifest, pluginManifest] = await Promise.allSettled([
+    buildGetters.getters.pageFiles(),
+    buildGetters.getters.getAssetsManifest(),
+    buildGetters.getters.pluginManifest(),
+  ]);
+
+  const buildEntries = { pageFiles, assetsManifest, pluginManifest };
+  return buildEntries;
+}
+
+declare global {
+  var __reveal_buildGetters:
+    | undefined
+    | {
+        getters: BuildGetters;
+      };
+}

package/dist/core/globals/contexts/globalContext/setup.ts

@@ -0,0 +1,4 @@
+import { setPageFilesAsync } from "../../../processing/getters/getPageFiles/index.js";
+import { getPageFilesExports } from "./getPageFilesExports.js";
+
+setPageFilesAsync(getPageFilesExports);

package/dist/core/globals/contexts/index.ts

@@ -0,0 +1 @@
+export * from "./globalContext";

package/dist/core/globals/logger/index.ts

@@ -0,0 +1 @@
+export * from "./numberOfStackTraceLinesToRemove.js";

package/dist/core/globals/logger/numberOfStackTraceLinesToRemove.ts

@@ -0,0 +1,3 @@
+export { numberOfStackTraceLinesToRemove };
+
+const numberOfStackTraceLinesToRemove = 2;

package/dist/core/globals/objects/index.ts

@@ -0,0 +1 @@
+export * from "./log";

package/dist/core/globals/objects/log.ts

@@ -0,0 +1,24 @@
+import { Logger } from "../../../types/interfaces/log";
+import getGlobalObject from "../../processing/getters/getGlobalObject";
+
+export { globalObject };
+
+const globalObject = getGlobalObject<{
+  alreadyLogged: Set<string>;
+  onBeforeLog?: () => void;
+  logger: Logger;
+  showStackTraceList: WeakSet<Error>;
+  alwaysShowStackTrace?: true;
+  disableAutomaticLinkInterception?: true;
+}>("utils/assert.ts", {
+  alreadyLogged: new Set(),
+  // Production logger. Overwritten by loggerNotProd.ts in non-production environments.
+  logger(msg, logType) {
+    if (logType === "info") {
+      console.log(msg);
+    } else {
+      console.warn(msg);
+    }
+  },
+  showStackTraceList: new WeakSet(),
+});

package/dist/core/globals/patterns/styleFileRE.ts

@@ -0,0 +1,3 @@
+// Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
+export const styleFileRE =
+  /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/dist/core/globals/tags/addPrefixAssertType.ts

@@ -0,0 +1,11 @@
+import pc from "@brillout/picocolors";
+import { Tag } from "../../../types/interfaces/tag";
+
+export { addPrefixAssertType };
+
+function addPrefixAssertType(msg: string, tag: Tag): string {
+  let prefix = `[${tag}]`;
+  const color = tag === "Warning" ? "yellow" : "red";
+  prefix = pc.bold(pc[color](prefix));
+  return `${prefix}${msg}`;
+}

package/dist/core/globals/tags/addPrefixProjectName.ts

@@ -0,0 +1,9 @@
+import { projectTag } from "./projectTag";
+import { projectTagWithVersion } from "./projectTagWithVersion";
+
+export { addPrefixProjectName };
+
+function addPrefixProjectName(msg: string, showProjectVersion = false): string {
+  const prefix = showProjectVersion ? projectTagWithVersion : projectTag;
+  return `${prefix}${msg}`;
+}

package/dist/core/globals/tags/projectTag.ts

@@ -0,0 +1,3 @@
+export { projectTag };
+
+const projectTag = `[reveal]` as const;

package/dist/core/globals/tags/projectTagWithVersion.ts

@@ -0,0 +1,5 @@
+import { projectInfo } from "../versions/projectInfo";
+
+export { projectTagWithVersion };
+
+const projectTagWithVersion = `[reveal@${projectInfo.projectVersion}]` as const;

package/dist/core/globals/versions/PROJECT_VERSION.ts

@@ -0,0 +1,2 @@
+// Automatically updated by @brillout/release-me
+export const PROJECT_VERSION = "0.4.200" as const;

package/dist/core/globals/versions/projectInfo.ts

@@ -0,0 +1,5 @@
+import { PROJECT_VERSION } from "./PROJECT_VERSION.js";
+export const projectInfo = {
+  projectName: "Reveal" as const,
+  projectVersion: PROJECT_VERSION,
+};

package/dist/core/handlers/handleErrorWithoutErrorPage.ts

@@ -0,0 +1,70 @@
+export { handleErrorWithoutErrorPage }
+
+import pc from "@brillout/picocolors"
+
+import type { PageContextAfterRender } from "../../core/renderer/page/renderPageAlreadyRouted.js"
+import {
+  assert,
+  assertWarning,
+  objectAssign,
+} from "../../core/renderer/stream/utils.js"
+
+import type { PageConfigRuntime } from "../../types/interfaces/page.js"
+import { getGlobalContext } from "../globals/contexts/globalContext/index.js"
+
+import { GetPageAssets } from "../processing/getters/getPageAssets.js"
+import { stringify } from "../processing/serializers/stringify.js"
+import {
+  createHttpResponseError,
+  createHttpResponsePage,
+} from "../targets/http/createHttpResponse.js"
+import {PageFile} from "../__internal/index.js"
+
+// When the user hasn't defined _error.page.js
+async function handleErrorWithoutErrorPage<
+  PageContext extends {
+    isClientSideNavigation: boolean
+    errorWhileRendering: null | Error
+    is404: null | boolean
+    pageId: null
+    _pageFilesAll: PageFile[]
+    _pageConfigs: PageConfigRuntime[]
+    urlOriginal: string
+  },
+>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender> {
+  assert(pageContext.pageId === null)
+  assert(pageContext.errorWhileRendering || pageContext.is404)
+
+  {
+    const isV1 = pageContext._pageConfigs.length > 0
+    warnMissingErrorPage(isV1)
+  }
+
+  if (!pageContext.isClientSideNavigation) {
+    const httpResponse = await createHttpResponseError(pageContext)
+    objectAssign(pageContext, { httpResponse })
+    return pageContext
+  } else {
+    const __getPageAssets: GetPageAssets = async () => []
+    objectAssign(pageContext, { __getPageAssets })
+    const httpResponse = await createHttpResponsePage(
+      stringify({ serverSideError: true }),
+      null,
+      pageContext
+    )
+    objectAssign(pageContext, { httpResponse })
+    return pageContext
+  }
+}
+
+function warnMissingErrorPage(isV1: boolean): void {
+  const globalContext = getGlobalContext()
+  if (!globalContext.isProduction) {
+    const msg = [
+      `No ${isV1 ? "error page" : pc.cyan("_error.page.js")} found,`,
+      "we recommend defining one",
+      "https://reveal.dev/error-page",
+    ].join(" ")
+    assertWarning(false, msg, { onlyOnce: true })
+  }
+}

package/dist/core/handlers/handlePageContext.ts

@@ -0,0 +1,15 @@
+import { PageContextServer } from "../../types/interfaces/context"
+
+function handlePageContext(pageContext: PageContextServer) {
+  // Type guard
+  if ("routeParams" in pageContext && pageContext.routeParams === undefined) {
+    // Handle the undefined routeParams for PageContextClient
+    pageContext.routeParams = {}
+  }
+
+  const serverContext = pageContext
+
+  return serverContext
+}
+
+export default handlePageContext

package/dist/core/handlers/handlePageContextRequestUrl.ts

@@ -0,0 +1,56 @@
+export { handlePageContextRequestUrl };
+
+import {
+  assert,
+  baseServer,
+  parseUrl,
+  slice,
+} from "../../core/renderer/stream/utils.js";
+import {
+  doNotCreateExtraDirectory,
+  pageContextJsonFileExtension,
+} from "../processing/getters/getPageContextRequestUrl.js";
+
+// See shared/getPageContextRequestUrl.ts
+function handlePageContextRequestUrl(url: string): {
+  urlWithoutPageContextRequestSuffix: string;
+  isPageContextRequest: boolean;
+} {
+  if (!hasSuffix(url)) {
+    return {
+      urlWithoutPageContextRequestSuffix: url,
+      isPageContextRequest: false,
+    };
+  }
+  return {
+    urlWithoutPageContextRequestSuffix: removePageContextUrlSuffix(url),
+    isPageContextRequest: true,
+  };
+}
+
+function hasSuffix(url: string): boolean {
+  const { pathnameOriginal, pathname } = parseUrl(url, baseServer);
+  assert(
+    pathnameOriginal.endsWith(pageContextJsonFileExtension) ===
+      pathname.endsWith(pageContextJsonFileExtension),
+    `URL: ${url}`,
+  );
+  return pathnameOriginal.endsWith(pageContextJsonFileExtension);
+}
+
+function removePageContextUrlSuffix(url: string): string {
+  const urlParsed = parseUrl(url, baseServer);
+  // We cannot use `urlParsed.pathname` because it would break the `urlParsed.pathnameOriginal` value of subsequent `parseUrl()` calls.
+  const { origin, pathnameOriginal, searchOriginal, hashOriginal } = urlParsed;
+  assert(doNotCreateExtraDirectory === false);
+  const urlSuffix = `/index${pageContextJsonFileExtension}`;
+  assert(pathnameOriginal.endsWith(urlSuffix), `URL: ${url}`);
+  let pathnameModified = slice(pathnameOriginal, 0, -1 * urlSuffix.length);
+  if (pathnameModified === "") pathnameModified = "/";
+  assert(
+    url ===
+      `${origin || ""}${pathnameOriginal}${searchOriginal || ""}${hashOriginal || ""}`,
+    `URL: ${url}`,
+  );
+  return `${origin || ""}${pathnameModified}${searchOriginal || ""}${hashOriginal || ""}`;
+}

package/dist/core/handlers/openFacebook.ts

@@ -0,0 +1,20 @@
+const openFacebook = (
+  event?: React.MouseEvent<HTMLButtonElement>,
+  // eslint-disable-next-line prettier/prettier
+  url = "https://www.facebook.com/groups/StreetbeefsScrapyard/",
+) => {
+  try {
+    if (event) {
+      event.preventDefault(); // Prevent default behavior if event is provided
+    }
+    const newWindow = window.open(url, "_blank", "noopener,noreferrer");
+    if (newWindow) newWindow.opener = null;
+  } catch (error) {
+    console.error("Failed to open Facebook URL:", error);
+    // User-friendly message
+    alert("Unable to open Facebook. Please check your popup blocker settings.");
+    // For a more advanced UI, replace the above line with a call to a custom notification component
+  }
+};
+
+export default openFacebook;

package/dist/core/hocs/clientOnly.tsx

@@ -0,0 +1,130 @@
+import React, {
+  Suspense,
+  forwardRef,
+  lazy,
+  useEffect,
+  useState,
+  ComponentProps,
+  ComponentType,
+  ReactNode,
+  ForwardedRef,
+} from "react";
+
+// The main clientOnly function
+function clientOnly<T extends ComponentType<any>>(
+  load: () => Promise<{ default: T } | T>,
+): ComponentType<ComponentProps<T> & { fallback?: ReactNode }> {
+  // If SSR is enabled, return fallback directly
+  //@ts-expect-error
+  import.meta.env ??= { SSR: true };
+
+  if (import.meta.env.SSR) {
+    return (props) => <>{props.fallback}</>;
+  }
+
+  // Lazy load the component
+  const LazyComponent = lazy(
+    (async () => {
+      try {
+        const LoadedComponent = await load();
+        return "default" in LoadedComponent
+          ? LoadedComponent
+          : { default: LoadedComponent };
+      } catch (error) {
+        console.error("Component loading failed:", error);
+        // Return a minimal error component - use double assertion for generic constraint
+        const ErrorComponent = () => <p>Error loading component.</p>;
+        return { default: ErrorComponent as unknown as T };
+      }
+    }) as () => Promise<{ default: T }>
+  );
+
+  // Wrap LazyComponent to forward the ref
+  const WrappedComponent = forwardRef<
+    unknown,
+    ComponentProps<T> & { fallback?: ReactNode }
+  >((props, ref: ForwardedRef<unknown>) => {
+    const [mounted, setMounted] = useState(false);
+
+    useEffect(() => {
+      setMounted(true);
+    }, []);
+
+    // If not mounted, render fallback
+    if (!mounted) {
+      return <>{props.fallback}</>;
+    }
+
+    const { fallback, ...restProps } = props;
+
+    // Use Suspense to handle lazy loading
+    return (
+      <Suspense fallback={fallback || null}>
+        {/* Forward the ref to the lazy component */}
+        {/* @ts-expect-error - ref forwarding with generic component types requires type assertion */}
+        <LazyComponent {...(restProps as ComponentProps<T>)} ref={ref} />
+      </Suspense>
+    );
+  });
+
+  // Type assertion to ensure the correct type
+  return WrappedComponent as unknown as ComponentType<
+    ComponentProps<T> & { fallback?: ReactNode }
+  >;
+}
+
+export { clientOnly };
+
+// export { clientOnly };
+
+// import React, {
+//   Suspense,
+//   forwardRef,
+//   lazy,
+//   useEffect,
+//   useState,
+//   type ComponentProps,
+//   type ComponentType,
+//   type ReactNode,
+// } from "react";
+
+// function clientOnly<T extends ComponentType<any>>(
+//   load: () => Promise<{ default: T } | T>,
+// ): ComponentType<ComponentProps<T> & { fallback?: ReactNode }> {
+//   // Client side: always bundled by Vite, import.meta.env.SSR === false
+//   // Server side: may or may not be bundled by Vite, import.meta.env.SSR === true || import.meta.env === undefined
+//   //@ts-expect-error
+//   import.meta.env ??= { SSR: true };
+//   if (import.meta.env.SSR) {
+//     return (props) => <>{props.fallback}</>;
+//   } else {
+//     const Component = lazy(() =>
+//       load()
+//         .then((LoadedComponent) =>
+//           "default" in LoadedComponent
+//             ? LoadedComponent
+//             : { default: LoadedComponent },
+//         )
+//         .catch((error) => {
+//           console.error("Component loading failed:", error);
+//           return { default: (() => <p>Error loading component.</p>) as any };
+//         }),
+//     );
+
+//     return forwardRef<any, any>((props, ref) => {
+//       const [mounted, setMounted] = useState(false);
+//       useEffect(() => {
+//         setMounted(true);
+//       }, []);
+//       if (!mounted) {
+//         return <>{props.fallback}</>;
+//       }
+//       const { fallback, ...rest } = props;
+//       return (
+//         <Suspense fallback={<>{props.fallback}</>}>
+//           <Component {...rest} ref={ref} />
+//         </Suspense>
+//       );
+//     }) as ComponentType<ComponentProps<T> & { fallback?: ReactNode }>;
+//   }
+// }

package/dist/core/hooks/callCumulativeHooks.ts

@@ -0,0 +1,22 @@
+import { providePageContext } from "./executeHook";
+
+export { callCumulativeHooks };
+
+async function callCumulativeHooks(
+  values: undefined | unknown[],
+  pageContext: Record<string, any>,
+): Promise<unknown[]> {
+  if (!values) return [];
+  const valuesPromises = values.map((val) => {
+    if (typeof val === "function") {
+      providePageContext(pageContext);
+      // Hook
+      return val(pageContext);
+    } else {
+      // Plain value
+      return val;
+    }
+  });
+  const valuesResolved = await Promise.allSettled(valuesPromises);
+  return valuesResolved;
+}

package/dist/core/hooks/executeHook.ts

@@ -0,0 +1,118 @@
+export { executeHook, getPageContext, isUserHookError, providePageContext }
+
+import {
+  PageContextClient,
+  PageContextServer,
+} from "../../types/interfaces/context.js"
+
+import { assertWarning } from "../gaurds/assertions/assertWarning/index.js"
+import { isObject } from "../gaurds/validators/isObject.js"
+import getGlobalObject from "../processing/getters/getGlobalObject.js"
+import type { Hook, HookLoc } from "../processing/getters/getHook.js"
+import { getProjectError } from "../processing/getters/getProjectError.js"
+import { humanizeTime } from "../utils/time/humanizeTime.js"
+
+const globalObject = getGlobalObject("utils/executeHook.ts", {
+  userHookErrors: new WeakMap<object, HookLoc>(),
+  pageContext: null as PageContextUnknown,
+})
+
+type PageContextUnknown = null | Record<string, any>
+
+function isUserHookError(err: unknown): false | HookLoc {
+  if (!isObject(err)) return false
+  return globalObject.userHookErrors.get(err) ?? false
+}
+
+function executeHook<T = unknown>(
+  hookFnCaller: () => T,
+  hook: Omit<Hook, "hookFn">,
+  pageContext: PageContextUnknown
+): Promise<T> {
+  const {
+    hookName,
+    hookFilePath,
+    hookTimeout: { error: timeoutErr, warning: timeoutWarn },
+  } = hook
+
+  let resolve!: (ret: T) => void
+  let reject!: (err: unknown) => void
+  const promise = new Promise<T>((resolve_, reject_) => {
+    resolve = (ret) => {
+      clearTimeouts()
+      resolve_(ret)
+    }
+    reject = (err) => {
+      clearTimeouts()
+      reject_(err)
+    }
+  })
+
+  const clearTimeouts = () => {
+    if (currentTimeoutWarn) clearTimeout(currentTimeoutWarn)
+    if (currentTimeoutErr) clearTimeout(currentTimeoutErr)
+  }
+  const currentTimeoutWarn =
+    isNotDisabled(timeoutWarn) &&
+    setTimeout(() => {
+      assertWarning(
+        false,
+        `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${humanizeTime(
+          timeoutWarn
+        )} (https://reveal.dev/hooksTimeout)`,
+        { onlyOnce: false }
+      )
+    }, timeoutWarn)
+  const currentTimeoutErr =
+    isNotDisabled(timeoutErr) &&
+    setTimeout(() => {
+      const err = getProjectError(
+        `The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${humanizeTime(
+          timeoutErr
+        )} (https://reveal.dev/hooksTimeout)`
+      )
+      reject(err)
+    }, timeoutErr)
+  ;(async () => {
+    try {
+      providePageContext(pageContext)
+      const ret = await hookFnCaller()
+      resolve(ret)
+    } catch (err) {
+      if (isObject(err)) {
+        globalObject.userHookErrors.set(err, { hookName, hookFilePath })
+      }
+      reject(err)
+    }
+  })()
+
+  return promise
+}
+
+function isNotDisabled(timeout: false | number): timeout is number {
+  return !!timeout && timeout !== Infinity
+}
+
+/**
+ * Access `pageContext` object inside reveal hooks, in order to create universal hooks.
+ *
+ * https://reveal.dev/getPageContext
+ */
+function getPageContext<
+  PageContext = PageContextClient | PageContextServer,
+>(): null | PageContext {
+  return globalObject.pageContext as any
+}
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://reveal.dev/getPageContext
+ */
+function providePageContext(pageContext: PageContextUnknown) {
+  globalObject.pageContext = pageContext
+  // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+  // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+  Promise.resolve().then(() => {
+    globalObject.pageContext = null
+  })
+}

package/dist/core/hooks/useConfig/configsCumulative.ts

@@ -0,0 +1,6 @@
+export const configsCumulative = [
+  "Head",
+  "bodyAttributes",
+  "htmlAttributes",
+] as const;
+export type ConfigsCumulative = (typeof configsCumulative)[number];

package/dist/core/hooks/useConfig/useConfig-client.ts

@@ -0,0 +1,82 @@
+// Client-side useConfig.ts
+/**
+ * Client-side useConfig hook
+ * @see {@link ./useConfig-server} - server counterpart
+ */
+export { useConfig }
+
+import { ExtendedPageContextClient } from "../../../types/interfaces/context.js"
+import type { ConfigFromHook } from "../../../types/namespaces/Config.js"
+import { usePageContext } from "../../../ui/hooks/usePageContext.js"
+import { applyHeadSettings } from "../../dom/applyHeadSettings.js"
+import { getPageContext } from "../executeHook.js"
+
+function useConfig(): (config: ConfigFromHook) => void {
+  let pageContext = getPageContext() as ExtendedPageContextClient
+  if (pageContext)
+    return (config: ConfigFromHook) =>
+      setPageContextConfigFromHook(config, pageContext)
+
+  // Component
+  pageContext = usePageContext() as ExtendedPageContextClient
+  return (config: ConfigFromHook) => {
+    if (!("_headAlreadySet" in pageContext)) {
+      setPageContextConfigFromHook(config, pageContext)
+    } else {
+      applyHead(config)
+    }
+  }
+}
+
+function setPageContextConfigFromHook(
+  config: ConfigFromHook,
+  pageContext: ExtendedPageContextClient
+) {
+  pageContext._configFromHook ??= {}
+  Object.assign(pageContext._configFromHook, config)
+}
+
+function applyHead(config: ConfigFromHook) {
+  const { title, lang } = config
+  applyHeadSettings(title, lang)
+}
+
+// export { useConfig };
+
+// import type { PageContext } from "reveal/types";
+// import type { PageContextInternal } from "../../types/PageContext.js";
+// import type { ConfigFromHook } from "../../types/Config.js";
+// import { usePageContext } from "../usePageContext.js";
+// import { getPageContext } from "reveal/getPageContext";
+// import { applyHeadSettings } from "../../integration/applyHeadSettings.js";
+
+// function useConfig(): (config: ConfigFromHook) => void {
+//   // reveal hook
+//   let pageContext = getPageContext() as PageContext & PageContextInternal;
+//   if (pageContext)
+//     return (config: ConfigFromHook) =>
+//       setPageContextConfigFromHook(config, pageContext);
+
+//   // Component
+//   pageContext = usePageContext();
+//   return (config: ConfigFromHook) => {
+//     if (!("_headAlreadySet" in pageContext)) {
+//       setPageContextConfigFromHook(config, pageContext);
+//     } else {
+//       applyHead(config);
+//     }
+//   };
+// }
+
+// function setPageContextConfigFromHook(
+//   config: ConfigFromHook,
+//   pageContext: PageContextInternal,
+// ) {
+//   pageContext._configFromHook ??= {};
+//   Object.assign(pageContext._configFromHook, config);
+// }
+
+// function applyHead(config: ConfigFromHook) {
+//   const { title, lang } = config;
+//   applyHeadSettings(title, lang);
+// }