@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getExportPath.spec.ts

@@ -0,0 +1,34 @@
+import { getExportPath } from "./getExportPath.js";
+import { expect, describe, it } from "vitest";
+
+describe("getExportPath()", () => {
+  it("works", () => {
+    expect(t(["prop"])).toBe("export { prop }");
+    expect(t(["default", "prop"])).toBe("export default { prop }");
+    expect(t(["prop", "nested"])).toBe("export { prop { nested } }");
+    expect(t(["prop", "nested1", "nested2"])).toBe(
+      "export { prop { nested1 { nested2 } } }",
+    );
+    expect(t(["default", "nested1", "nested2"])).toBe(
+      "export default { nested1 { nested2 } }",
+    );
+    expect(t(["default", "meta", "onBeforeRenderIsomorph", "effect"])).toBe(
+      "export default { meta { onBeforeRenderIsomorph { effect } } }",
+    );
+  });
+  it("succint", () => {
+    expect(t(["default"])).toBe(null);
+    expect(t(["route"], "route")).toBe(null);
+    expect(t(["route"], "route2")).toBe("export { route }");
+  });
+  it("edge cases work", () => {
+    expect(t(["*"])).toBe(null);
+  });
+});
+
+function t(
+  fileExportPathToShowToUser: null | string[],
+  configName = "bla",
+): null | string {
+  return getExportPath(fileExportPathToShowToUser, configName);
+}

package/dist/core/processing/getters/getExportPath.ts

@@ -0,0 +1,33 @@
+import { assert } from "../../gaurds/assertions/assert";
+
+export { getExportPath };
+
+function getExportPath(
+  fileExportPathToShowToUser: null | string[],
+  configName: string,
+): null | string {
+  if (!fileExportPathToShowToUser) return null;
+  let [exportName, ...exportObjectPath] = fileExportPathToShowToUser;
+  if (!exportName) return null;
+  if (
+    exportObjectPath.length === 0 &&
+    ["*", "default", configName].includes(exportName)
+  )
+    return null;
+  assert(exportName !== "*");
+
+  let prefix = "";
+  let suffix = "";
+  if (exportName === "default") {
+    prefix = "export default";
+  } else {
+    prefix = "export";
+    exportObjectPath = [exportName, ...exportObjectPath];
+  }
+  exportObjectPath.forEach((prop) => {
+    prefix = `${prefix} { ${prop}`;
+    suffix = ` }${suffix}`;
+  });
+  const exportPath = prefix + suffix;
+  return exportPath;
+}

package/dist/core/processing/getters/getFileExtension.ts

@@ -0,0 +1,19 @@
+export { getFileExtension };
+
+import { slice } from "../../utils/array/slice.js";
+
+function getFileExtension(id: string) {
+  id = id.split("?")[0]!;
+
+  const fileName = slice(id.split("/"), -1, 0)[0];
+  if (!fileName) {
+    return null;
+  }
+
+  const fileExtension = slice(fileName.split("."), -1, 0)[0];
+  if (!fileExtension) {
+    return null;
+  }
+
+  return fileExtension;
+}

package/dist/core/processing/getters/getFilePath.ts

@@ -0,0 +1,269 @@
+export {
+  assertModuleId,
+  cleanFilePathUnkown,
+  getFilePathAbsoluteUserRootDir,
+  getFilePathResolved,
+  getFilePathToShowToUserFromUnkown,
+  getFilePathUnresolved,
+  getModuleFilePathAbsolute,
+  getModuleFilePathRelative,
+};
+
+import path from "path";
+import type { ResolvedConfig } from "vite";
+import {
+  assert,
+  assertFilePathAbsoluteFilesystem,
+  assertIsNpmPackageImport,
+  assertPosixPath,
+  toPosixPath,
+} from "../../../plugins/utils.js";
+import type {
+  FilePathResolved,
+  FilePathUnresolved,
+} from "../../../types/interfaces/file.js";
+
+function getFilePathResolved(
+  args: {
+    userRootDir: string;
+  } & (
+    | { filePathAbsoluteFilesystem: string; importPathAbsolute: string }
+    | { filePathAbsoluteUserRootDir: string; importPathAbsolute?: string }
+  ),
+): FilePathResolved {
+  const { userRootDir } = args;
+
+  let filePathAbsoluteFilesystem: string;
+  let filePathAbsoluteUserRootDir: string | null;
+  if ("filePathAbsoluteFilesystem" in args) {
+    filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
+    filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({
+      filePathAbsoluteFilesystem,
+      userRootDir,
+    });
+  } else {
+    filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
+    filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({
+      filePathAbsoluteUserRootDir,
+      userRootDir,
+    });
+  }
+
+  assert(filePathAbsoluteFilesystem);
+  assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
+  const filePathToShowToUserResolved =
+    filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+  assert(filePathToShowToUserResolved);
+
+  assertPosixPath(filePathAbsoluteFilesystem);
+  const fileName = path.posix.basename(filePathAbsoluteFilesystem);
+
+  const filePathResolved: FilePathResolved = {
+    ...getComputedProps(args),
+    filePathAbsoluteFilesystem,
+    filePathToShowToUserResolved,
+    fileName,
+  };
+  return filePathResolved;
+}
+
+function getComputedProps(
+  args:
+    | { importPathAbsolute: string }
+    | { filePathAbsoluteUserRootDir: string; importPathAbsolute?: string },
+) {
+  if ("filePathAbsoluteUserRootDir" in args) {
+    const importPathAbsolute = args.importPathAbsolute ?? null;
+    const { filePathAbsoluteUserRootDir } = args;
+    if (importPathAbsolute) assertIsNpmPackageImport(importPathAbsolute);
+    return {
+      importPathAbsolute,
+      filePathAbsoluteUserRootDir,
+      filePathAbsoluteVite: filePathAbsoluteUserRootDir,
+      filePathToShowToUser: filePathAbsoluteUserRootDir,
+    };
+  } else {
+    return getComputedPropsImportPathAbsolute(args);
+  }
+}
+function getComputedPropsImportPathAbsolute(args: {
+  importPathAbsolute: string;
+}) {
+  const { importPathAbsolute } = args;
+  assertIsNpmPackageImport(importPathAbsolute);
+  return {
+    filePathAbsoluteUserRootDir: null,
+    importPathAbsolute,
+    filePathAbsoluteVite: importPathAbsolute,
+    filePathToShowToUser: importPathAbsolute,
+  };
+}
+
+function getFilePathUnresolved(args: {
+  importPathAbsolute: string;
+}): FilePathUnresolved {
+  return {
+    ...getComputedPropsImportPathAbsolute(args),
+    filePathAbsoluteFilesystem: null,
+  };
+}
+
+function getFilePathAbsoluteUserFilesystem({
+  filePathAbsoluteUserRootDir,
+  userRootDir,
+}: {
+  filePathAbsoluteUserRootDir: string;
+  userRootDir: string;
+}): string {
+  assertPosixPath(filePathAbsoluteUserRootDir);
+  assertPosixPath(userRootDir);
+  assertFilePathAbsoluteFilesystem(userRootDir);
+
+  const filePathAbsoluteFilesystem = path.posix.join(
+    userRootDir,
+    filePathAbsoluteUserRootDir,
+  );
+  assertFilePathAbsoluteFilesystem(userRootDir);
+  return filePathAbsoluteFilesystem;
+}
+function getFilePathAbsoluteUserRootDir({
+  filePathAbsoluteFilesystem,
+  userRootDir,
+}: {
+  filePathAbsoluteFilesystem: string;
+  userRootDir: string;
+}): string | null {
+  const { filePathAbsoluteUserRootDir } = getFilePathRelative({
+    filePathAbsoluteFilesystem,
+    userRootDir,
+  });
+  return filePathAbsoluteUserRootDir;
+}
+function getFilePathRelative({
+  filePathAbsoluteFilesystem,
+  userRootDir,
+}: {
+  filePathAbsoluteFilesystem: string;
+  userRootDir: string;
+}) {
+  assertPosixPath(filePathAbsoluteFilesystem);
+  assertPosixPath(userRootDir);
+  assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
+  assertFilePathAbsoluteFilesystem(userRootDir);
+
+  const filePathRelativeUserRootDir = path.posix.relative(
+    userRootDir,
+    filePathAbsoluteFilesystem,
+  );
+
+  if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+    assert(filePathRelativeUserRootDir.startsWith("../"));
+    return {
+      filePathAbsoluteUserRootDir: null,
+      filePathRelativeUserRootDir,
+    };
+  } else {
+    assert(
+      !filePathRelativeUserRootDir.startsWith("/") &&
+        /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+        !filePathRelative.startsWith('.') &&
+        */
+        !filePathRelativeUserRootDir.startsWith("./") &&
+        !filePathRelativeUserRootDir.startsWith("../"),
+    );
+    const filePathAbsoluteUserRootDir = `/${filePathRelativeUserRootDir}`;
+    assert(
+      filePathAbsoluteUserRootDir ===
+        getFilePathAbsoluteUserRootDir2(
+          filePathAbsoluteFilesystem,
+          userRootDir,
+        ),
+    );
+    return { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
+  }
+}
+
+function getModuleFilePathAbsolute(
+  moduleId: string,
+  config: ResolvedConfig,
+): string {
+  const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } =
+    getModuleFilePath(moduleId, config);
+  return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+}
+function getModuleFilePathRelative(
+  moduleId: string,
+  config: ResolvedConfig,
+): string {
+  const { filePathRelativeUserRootDir } = getModuleFilePath(moduleId, config);
+  return filePathRelativeUserRootDir;
+}
+function getModuleFilePath(moduleId: string, config: ResolvedConfig) {
+  const userRootDir = config.root;
+  assertModuleId(moduleId);
+  assertPosixPath(userRootDir);
+  assertFilePathAbsoluteFilesystem(userRootDir);
+
+  const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
+  assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
+
+  const { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir } =
+    getFilePathRelative({
+      filePathAbsoluteFilesystem,
+      userRootDir,
+    });
+
+  return {
+    filePathAbsoluteFilesystem,
+    filePathAbsoluteUserRootDir,
+    filePathRelativeUserRootDir,
+  };
+}
+function assertModuleId(moduleId: string) {
+  assertPosixPath(moduleId);
+  assertFilePathAbsoluteFilesystem(moduleId); // Can moduleId be something else than the filesystem absolute path?
+}
+
+function getFilePathToShowToUserFromUnkown(
+  // We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
+  filePathUnkown: string,
+  userRootDir: string,
+): string {
+  assertPosixPath(userRootDir);
+  assertFilePathAbsoluteFilesystem(userRootDir);
+
+  filePathUnkown = cleanFilePathUnkown(filePathUnkown);
+
+  if (!filePathUnkown.startsWith(userRootDir)) {
+    return filePathUnkown;
+  } else {
+    return getFilePathAbsoluteUserRootDir2(filePathUnkown, userRootDir);
+  }
+}
+
+function getFilePathAbsoluteUserRootDir2(
+  filePathAbsoluteFilesystem: string,
+  userRootDir: string,
+): string {
+  assert(filePathAbsoluteFilesystem.startsWith(userRootDir));
+  let filePathAbsoluteUserRootDir = filePathAbsoluteFilesystem.slice(
+    userRootDir.length,
+  );
+  if (!filePathAbsoluteUserRootDir.startsWith("/"))
+    filePathAbsoluteUserRootDir = "/" + filePathAbsoluteUserRootDir;
+  return filePathAbsoluteUserRootDir;
+}
+
+function cleanFilePathUnkown(filePathUnknown: string) {
+  filePathUnknown = toPosixPath(filePathUnknown);
+  filePathUnknown = cleanModuleId(filePathUnknown);
+  return filePathUnknown;
+}
+
+function cleanModuleId(moduleId: string): string {
+  // remove query
+  const parts = moduleId.split("?");
+  if (parts.length > 1) parts.pop();
+  assert(parts.length >= 1);
+  return parts.join("?");
+}

package/dist/core/processing/getters/getGlobalObject.ts

@@ -0,0 +1,53 @@
+import { assert } from "../../gaurds/assertions/assert";
+
+export default function getGlobalObject<
+  T extends Record<string, unknown> = never,
+>(
+  // We use the filename as key; each `getGlobalObject()` call should live inside a file with a unique filename.
+  key: `${string}.ts`,
+  defaultValue: T,
+): T {
+  // @ts-ignore
+  const globalObjectsAll = (globalThis[projectKey] =
+    // @ts-ignore
+    globalThis[projectKey] || {});
+  const globalObject = (globalObjectsAll[key] =
+    globalObjectsAll[key] || defaultValue);
+  return globalObject;
+}
+const projectKey = "_reveal_react";
+
+// export { getGlobalObject };
+export { assertIsSingleModuleInstance };
+
+// import { assert } from "./assert.js";
+// import { projectInfo } from "./projectInfo.js";
+
+// const projectKey = `_${projectInfo.projectName.toLowerCase()}` as const;
+
+// /** Share information across module instances. */
+// function getGlobalObject<T extends Record<string, unknown> = never>(
+//   // We use the filename (or file path) as key. There should be only one getGlobalObject() usage per file. Thus the key should be unique, assuming the filename (or file path) is unique.
+//   key: `${string}.ts`,
+//   defaultValue: T,
+// ): T {
+//   const globalObjects = getGlobalObjects();
+//   const globalObject = (globalObjects[key] =
+//     globalObjects[key] || defaultValue);
+//   return globalObject;
+// }
+
+// /** Assert that the module is instantiated only once. */
+function assertIsSingleModuleInstance(
+  // We use the filename (or file path) as key.
+  key: `${string}.ts`,
+): void {
+  const globalObjects = getGlobalObjects();
+  assert(!(key in globalObjects));
+}
+
+function getGlobalObjects() {
+  // @ts-ignore
+  const globalObjects = (globalThis[projectKey] = globalThis[projectKey] || {});
+  return globalObjects;
+}

package/dist/core/processing/getters/getHeadSetting.tsx

@@ -0,0 +1,36 @@
+export { getHeadSetting }
+
+// import type { PageContext } from "reveal/types";
+import type {
+  PageContext,
+  PageContextInternal,
+} from "../../../types/interfaces/context.js"
+import type { ConfigFromHookResolved } from "../../../types/namespaces/Config.js"
+import { isCallable } from "../../gaurds/validators/isCallable.js"
+import { configsCumulative } from "../../hooks/useConfig/configsCumulative.js"
+import { includes } from "../iterators/includes.js"
+
+// We use `any` instead of doing proper validation in order to save KBs sent to the client-side.
+
+function getHeadSetting<T>(
+  configName: keyof ConfigFromHookResolved,
+  pageContext: PageContext & PageContextInternal
+): undefined | T {
+  // Set by useConfig()
+  const valFromUseConfig = pageContext._configFromHook?.[configName]
+  // Set by +configName.js
+  const valFromConfig = (pageContext.config as Record<string, unknown>)[configName]
+
+  const getCallable = (val: unknown) =>
+    isCallable(val) ? val(pageContext) : val
+  if (!includes(configsCumulative, configName)) {
+    if (valFromUseConfig !== undefined) return valFromUseConfig as any
+    return getCallable(valFromConfig) as any
+  } else {
+    return [
+      //
+      ...((valFromConfig as any) ?? []).map(getCallable),
+      ...((valFromUseConfig as any) ?? []),
+    ] as any
+  }
+}

package/dist/core/processing/getters/getHook.ts

@@ -0,0 +1,222 @@
+export {
+  assertHook,
+  getHook,
+  getHook_setIsPrerenderering,
+  getHookFromPageConfig,
+  getHookFromPageConfigGlobal,
+};
+export type {
+  Hook,
+  HookLoc,
+  HookName,
+  HooksTimeoutProvidedByUser,
+  HookTimeout,
+};
+
+import pc from "@brillout/picocolors";
+import type {
+  HookName,
+  HookNameGlobal,
+  HookNamePage,
+} from "../../../types/interfaces/config.js";
+import type {
+  PageConfigGlobalRuntime,
+  PageConfigRuntime,
+} from "../../../types/interfaces/page.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js";
+import { isCallable } from "../../gaurds/validators/isCallable.js";
+import { getConfigValueRuntime } from "./getConfigValue.js";
+import getGlobalObject from "./getGlobalObject.js";
+import { getHookFilePathToShowToUser } from "./getHookFilePathToShowToUser.js";
+import type { PageContextExports } from "./getPageFiles/index.js";
+import { checkType } from "../../gaurds/assertions/checkType.js";
+import { isObject } from "../../gaurds/validators/isObject.js";
+
+const globalObject = getGlobalObject<{ isPrerendering?: true }>(
+  "getHook.ts",
+  {},
+);
+
+type Hook = HookLoc & { hookFn: HookFn; hookTimeout: HookTimeout };
+type HookLoc = { hookName: HookName; hookFilePath: string };
+type HookFn = (arg: unknown) => unknown;
+type HookTimeout = {
+  error: number | false;
+  warning: number | false;
+};
+// User Interface
+type HooksTimeoutProvidedByUser =
+  | false
+  | Partial<Record<HookName, false | Partial<HookTimeout>>>;
+type HooksTimeoutProvidedByUserNormalized =
+  | false
+  | Partial<Record<HookName, Partial<HookTimeout>>>;
+
+function getHook(
+  pageContext: PageContextExports,
+  hookName: HookName,
+): null | Hook {
+  if (!(hookName in pageContext)) {
+    return null;
+  }
+  const hooksTimeout = (pageContext as any)._config?.hooksTimeout;
+  const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+  const hookFn = (pageContext as unknown as Record<HookName, unknown>)[
+    hookName
+  ];
+  const file = (pageContext as any)[hookName]?.[0];
+  if (!file || file.exportValue !== hookFn || hookFn === null) return null;
+  const hookFilePath = file.filePath;
+  assert(hookFilePath);
+  assert(!hookFilePath.endsWith(" "));
+  assertHookFn(hookFn, { hookName, hookFilePath });
+  return { hookFn, hookName, hookFilePath, hookTimeout };
+}
+function getHookFromPageConfig(
+  pageConfig: PageConfigRuntime,
+  hookName: HookNamePage,
+): null | Hook {
+  const configValue = getConfigValueRuntime(pageConfig, hookName);
+  const hooksTimeout = getConfigValueRuntime(pageConfig, "hooksTimeout")?.value;
+  if (!configValue) return null;
+  const hookFn = configValue.value;
+  if (!hookFn) return null;
+  const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
+  // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
+  assert(hookFilePath);
+  assertHookFn(hookFn, { hookName, hookFilePath });
+  const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+  return { hookFn, hookName, hookFilePath, hookTimeout };
+}
+function getHookFromPageConfigGlobal(
+  pageConfigGlobal: PageConfigGlobalRuntime,
+  hookName: HookNameGlobal,
+): null | Hook {
+  const configValue = pageConfigGlobal.configValues[hookName];
+  if (!configValue) return null;
+  const hookFn = configValue.value;
+  if (!hookFn) return null;
+  const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
+  // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
+  assert(hookFilePath);
+  assertHookFn(hookFn, { hookName, hookFilePath });
+  // We could use the global value of configooksTimeout but it requires some non-trivial refactoring
+  const hookTimeout = getHookTimeoutDefault(hookName);
+  return { hookFn, hookName, hookFilePath, hookTimeout };
+}
+
+function assertHook<
+  TPageContext extends PageContextExports,
+  THookName extends PropertyKey & HookName,
+>(
+  pageContext: TPageContext,
+  hookName: THookName,
+): asserts pageContext is TPageContext & {
+  exports: Record<THookName, Function | undefined>;
+} {
+  getHook(pageContext, hookName);
+}
+
+function assertHookFn(
+  hookFn: unknown,
+  { hookName, hookFilePath }: { hookName: HookName; hookFilePath: string },
+): asserts hookFn is HookFn {
+  assert(hookName && hookFilePath);
+  assert(!hookName.endsWith(")"));
+  assertUsage(
+    isCallable(hookFn),
+    `Hook ${hookName}() defined by ${hookFilePath} should be a function`,
+  );
+  checkType<HookFn>(hookFn);
+}
+
+function getHookTimeout(
+  hooksTimeoutProvidedByUser: unknown,
+  hookName: HookName,
+): HookTimeout {
+  const hooksTimeoutProvidedbyUserNormalized =
+    getHooksTimeoutProvidedByUserNormalized(hooksTimeoutProvidedByUser);
+  if (hooksTimeoutProvidedbyUserNormalized === false)
+    return { error: false, warning: false };
+  const providedbyUser = hooksTimeoutProvidedbyUserNormalized[hookName];
+  const hookTimeout = getHookTimeoutDefault(hookName);
+  if (providedbyUser?.error !== undefined)
+    hookTimeout.error = providedbyUser.error;
+  if (providedbyUser?.warning !== undefined)
+    hookTimeout.warning = providedbyUser.warning;
+  return hookTimeout;
+}
+
+// Ideally this should be called only once and at build-time (to avoid bloating the client-side bundle), but we didn't implement any mechanism to valide config values at build-time yet
+function getHooksTimeoutProvidedByUserNormalized(
+  hooksTimeoutProvidedByUser: unknown,
+): HooksTimeoutProvidedByUserNormalized {
+  if (hooksTimeoutProvidedByUser === undefined) return {};
+  if (hooksTimeoutProvidedByUser === false) return false;
+  assertUsage(
+    isObject(hooksTimeoutProvidedByUser),
+    `Setting ${pc.cyan("hooksTimeout")} should be ${pc.cyan("false")} or an object`,
+  );
+
+  const hooksTimeoutProvidedByUserNormalized: HooksTimeoutProvidedByUserNormalized =
+    {};
+  Object.entries(hooksTimeoutProvidedByUser).forEach(
+    ([hookName, hookTimeoutProvidedbyUser]) => {
+      if (hookTimeoutProvidedbyUser === false) {
+        hooksTimeoutProvidedByUserNormalized[hookName as HookName] = {
+          error: false,
+          warning: false,
+        };
+        return;
+      }
+      assertUsage(
+        isObject(hookTimeoutProvidedbyUser),
+        `Setting ${pc.cyan(`hooksTimeout.${hookName}`)} should be ${pc.cyan("false")} or an object`,
+      );
+      const [error, warning] = ["error", "warning"].map((timeoutName) => {
+        const timeoutVal = hookTimeoutProvidedbyUser[timeoutName];
+        if (timeoutVal === undefined || timeoutVal === false) return timeoutVal;
+        const errPrefix =
+          `Setting ${pc.cyan(`hooksTimeout.${hookName}.${timeoutName}`)} should be` as const;
+        assertUsage(
+          typeof timeoutVal === "number",
+          `${errPrefix} ${pc.cyan("false")} or a number`,
+        );
+        assertUsage(timeoutVal > 0, `${errPrefix} a positive number`);
+        return timeoutVal;
+      });
+      hooksTimeoutProvidedByUserNormalized[hookName as HookName] = {
+        error,
+        warning,
+      };
+    },
+  );
+  return hooksTimeoutProvidedByUserNormalized;
+}
+
+function getHookTimeoutDefault(hookName: HookName): HookTimeout {
+  if (hookName === "onBeforeRoute") {
+    return {
+      error: 5 * 1000,
+      warning: 1 * 1000,
+    };
+  }
+
+  if (globalObject.isPrerendering) {
+    return {
+      error: 2 * 60 * 1000,
+      warning: 30 * 1000,
+    };
+  } else {
+    assert(!hookName.toLowerCase().includes("prerender"));
+  }
+
+  return {
+    error: 30 * 1000,
+    warning: 4 * 1000,
+  };
+}
+function getHook_setIsPrerenderering() {
+  globalObject.isPrerendering = true;
+}

package/dist/core/processing/getters/getHookFilePathToShowToUser.ts

@@ -0,0 +1,12 @@
+import { DefinedAtData } from "../../../types/interfaces/page";
+import { assert } from "../../gaurds/assertions/assert";
+import { getConfigValueFilePathToShowToUser } from "./getConfigValueFilePathToShowToUser";
+
+export { getHookFilePathToShowToUser };
+
+function getHookFilePathToShowToUser(definedAtData: DefinedAtData): string {
+  const filePathToShowToUser =
+    getConfigValueFilePathToShowToUser(definedAtData);
+  assert(filePathToShowToUser);
+  return filePathToShowToUser;
+}