@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getPageFiles/analyzePageServerSide.ts

@@ -0,0 +1,32 @@
+export { analyzePageServerSide }
+
+import {PageFile} from "../../../__internal"
+import { assert } from "../../../gaurds/assertions/assert/base"
+
+async function analyzePageServerSide(pageFilesAll: PageFile[], pageId: string) {
+  const pageFilesServerSide = pageFilesAll.filter(
+    (p: { fileType: string }) =>
+      p.fileType === ".page.server" || p.fileType === ".page.route"
+  )
+
+  const pageFilesServerSideOnly = pageFilesServerSide.filter(
+    (p: { fileType: string }) => p.fileType === ".page.server"
+  )
+  await Promise.allSettled(
+    pageFilesServerSideOnly.map(async (p: PageFile) => {
+      // In production, `exportNames` are preload
+      if (p.exportNames) {
+        return
+      }
+      assert(typeof p.loadExportNames === "function", pageId)
+      await p.loadExportNames()
+    })
+  )
+  const hasOnBeforeRenderServerSideOnlyHook = pageFilesServerSideOnly.some(
+    (p: PageFile) => {
+      assert(p.exportNames)
+      return p.exportNames?.includes("onBeforeRender") ?? false
+    }
+  )
+  return { hasOnBeforeRenderServerSideOnlyHook }
+}

package/dist/core/processing/getters/getPageFiles/getExportNames.ts

@@ -0,0 +1,16 @@
+export { getExportNames }
+
+import {PageFile} from "../../../__internal"
+import { assert } from "../../../gaurds/assertions/assert"
+
+function getExportNames(p: PageFile): string[] {
+  if (p.fileType === ".css") {
+    return []
+  }
+  if (p.exportNames) {
+    return p.exportNames
+  }
+  assert(p.fileExports, p.filePath)
+  const exportNames = Object.keys(p.fileExports)
+  return exportNames
+}

package/dist/core/processing/getters/getPageFiles/getExports.ts

@@ -0,0 +1,193 @@
+export { getPageContextExports }
+export type { ConfigEntries, From, PageContextExports, Source, Sources }
+
+import {
+  type ConfigDefinedAtOptional,
+  getConfigDefinedAtOptional,
+  getDefinedAtString,
+} from "../getConfigDefinedAt.js"
+
+import type { PageConfigRuntimeLoaded } from "../../../../types/interfaces/page.js"
+import { assert } from "../../../gaurds/assertions/assert/base.js"
+import { getConfigValueFilePathToShowToUser } from "../getConfigValueFilePathToShowToUser.js"
+
+/** All the config's values (including overriden ones) and where they come from.
+ *
+ * https://reveal.dev/pageContext
+ */
+type ConfigEntries = Record<
+  string,
+  {
+    configValue: unknown
+    configDefinedAt: ConfigDefinedAtOptional
+    configDefinedByFile: string | null
+  }[]
+>
+type PageContextExports = {
+  source: Source
+  sources: Sources
+  from: From
+}
+
+type From = {
+  configsStandard: Record<
+    string, // configName
+    SourceConfigsStandard
+  >
+  configsCumulative: Record<
+    string, // configName
+    SourceConfigsCumulative
+  >
+  configsComputed: Record<
+    string, // configName
+    SourceConfigsComputed
+  >
+}
+
+type Source = Record<
+  string, // configName
+  SourceAny
+>
+type Sources = Record<
+  string, // configName
+  SourceAny[]
+>
+type SourceHooks = {
+  type: "hooks"
+  value: unknown
+}
+
+type SourceRenderFailure = {
+  type: "renderFailure"
+  value: unknown
+}
+
+type SourceRevealInternal = {
+  type: "revealInternal"
+  value: unknown
+}
+
+type SourceAny =
+  | SourceConfigs
+  | SourceHooks
+  | SourceRenderFailure
+  | SourceRevealInternal
+
+type SourceConfigs =
+  | SourceConfigsStandard
+  | SourceConfigsCumulative
+  | SourceConfigsComputed
+
+type SourceConfigsStandard = {
+  type: "configsStandard"
+  value: unknown
+  definedAt: string
+}
+type SourceConfigsCumulative = {
+  type: "configsCumulative"
+  values: {
+    value: unknown
+    definedAt: string
+  }[]
+}
+type SourceConfigsComputed = {
+  type: "configsComputed"
+  value: unknown
+}
+
+function getPageContextExports(
+  pageConfig: PageConfigRuntimeLoaded | null,
+  pageConfigLoaded?: PageConfigRuntimeLoaded
+): PageContextExports {
+  const configEntries: ConfigEntries = {}
+  const config: Record<string, unknown> = {}
+
+  // V1 design
+  const source: Source = {}
+  const sources: Sources = {}
+  const addSrc = (src: SourceAny, configName: string) => {
+    source[configName] = src
+    sources[configName] ??= []
+    sources[configName]!.push(src)
+  }
+  const from: From = {
+    configsStandard: {},
+    configsCumulative: {},
+    configsComputed: {},
+  }
+  if (pageConfig) {
+    Object.entries(pageConfig.configValues).forEach(
+      ([configName, configValue]) => {
+        const { value } = configValue
+        const configValueFilePathToShowToUser =
+          getConfigValueFilePathToShowToUser(configValue.definedAtData)
+        const configDefinedAt = getConfigDefinedAtOptional(
+          "Config",
+          configName,
+          configValue.definedAtData
+        )
+
+        config[configName] = config[configName] ?? value
+        configEntries[configName] = configEntries[configName] ?? []
+        // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
+        assert(configEntries[configName]!.length === 0)
+        configEntries[configName]!.push({
+          configValue: value,
+          configDefinedAt,
+          configDefinedByFile: configValueFilePathToShowToUser,
+        })
+
+        if (configValue.type === "standard") {
+          const src: SourceConfigsStandard = {
+            type: "configsStandard",
+            value: configValue.value,
+            definedAt: getDefinedAtString(
+              configValue.definedAtData,
+              configName
+            ),
+          }
+          addSrc(src, configName)
+          from.configsStandard[configName] = src
+        }
+        if (configValue.type === "cumulative") {
+          const src: SourceConfigsCumulative = {
+            type: "configsCumulative",
+            values: configValue.value.map((value, i) => {
+              const definedAtFile = configValue.definedAtData[i]
+              assert(definedAtFile)
+              const definedAt = getDefinedAtString(definedAtFile, configName)
+              return {
+                value,
+                definedAt,
+              }
+            }),
+          }
+          addSrc(src, configName)
+          from.configsCumulative[configName] = src
+        }
+        if (configValue.type === "computed") {
+          const src: SourceConfigsComputed = {
+            type: "configsComputed",
+            value: configValue.value,
+          }
+          addSrc(src, configName)
+          from.configsComputed[configName] = src
+        }
+      }
+    )
+  }
+
+  const exports: Record<string, unknown> = {}
+  for (const [configName, configValue] of Object.entries(config)) {
+    exports[configName] = configValue
+  }
+
+  assert(!("default" in exports))
+
+  const pageContextExports = {
+    from,
+    source,
+    sources,
+  }
+  return pageContextExports
+}

package/dist/core/processing/getters/getPageFiles/index.ts

@@ -0,0 +1,9 @@
+// Types
+export type { PageContextExports } from "./getExports.js";
+
+export { getPageContextExports } from "./getExports.js";
+export {
+  getPageFilesAll,
+  setPageFiles,
+  setPageFilesAsync,
+} from "./setPageFiles.js";

package/dist/core/processing/getters/getPageFiles/parseGlobResults.ts

@@ -0,0 +1,167 @@
+export { parseGlobResults };
+
+import type {
+  PageConfigGlobalRuntime,
+  PageConfigRuntime,
+} from "../../../../types/interfaces/page.js";
+import { PageFile } from "../../../__internal/index.js";
+import { assert } from "../../../gaurds/assertions/assert/index.js";
+import { isCallable } from "../../../gaurds/validators/isCallable.js";
+import {
+  assertCast,
+  hasProp,
+  isArray,
+  isObject,
+} from "../../../utils/index.js";
+import type {
+  PageConfigGlobalRuntimeSerialized,
+  PageConfigRuntimeSerialized,
+} from "../../serializers/serializePage/PageConfigSerialized.js";
+import { parsePageConfigs } from "../../serializers/serializePage/parsePageConfigs.js";
+
+const createPageFileObject = (filePath: string) => {
+  const fileType = filePath.includes(".page.") ? "page" : "config";
+  return {
+    filePath,
+    fileType,
+    isEnv: false,
+    isRelevant: true,
+    isDefaultPageFile: false,
+    isRendererPageFile: false,
+    pageId: filePath,
+    loadExportNames: () => {},
+    isErrorPageFile: false,
+  } as unknown as PageFile;
+};
+function parseGlobResults(pageFilesExports: unknown): {
+  pageFiles: PageFile[];
+  pageConfigs: PageConfigRuntime[];
+  pageConfigGlobal: PageConfigGlobalRuntime;
+} {
+  assert(hasProp(pageFilesExports, "pageFilesLazy", "object"));
+  assert(hasProp(pageFilesExports, "pageFilesEager", "object"));
+  assert(hasProp(pageFilesExports, "pageFilesExportNamesLazy", "object"));
+  assert(hasProp(pageFilesExports, "pageFilesExportNamesEager", "object"));
+  assert(hasProp(pageFilesExports.pageFilesLazy, ".page"));
+  assert(
+    hasProp(pageFilesExports.pageFilesLazy, ".page.client") ||
+      hasProp(pageFilesExports.pageFilesLazy, ".page.server"),
+  );
+  assert(hasProp(pageFilesExports, "pageFilesList", "string[]"));
+
+  assert(hasProp(pageFilesExports, "pageConfigsSerialized"));
+  assert(hasProp(pageFilesExports, "pageConfigGlobalSerialized"));
+  const { pageConfigsSerialized, pageConfigGlobalSerialized } =
+    pageFilesExports;
+  assertPageConfigsSerialized(pageConfigsSerialized);
+  assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
+  const { pageConfigs, pageConfigGlobal } = parsePageConfigs(
+    pageConfigsSerialized,
+    pageConfigGlobalSerialized,
+  );
+
+  const pageFilesMap: Record<string, PageFile> = {};
+  parseGlobResult(pageFilesExports.pageFilesLazy).forEach(
+    ({ filePath, pageFile, globValue }) => {
+      pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+      const loadModule = globValue;
+      assertLoadModule(loadModule);
+      pageFile.loadFile = async () => {
+        if (!("fileExports" in pageFile)) {
+          pageFile.fileExports = await loadModule();
+        }
+      };
+    },
+  );
+  parseGlobResult(pageFilesExports.pageFilesExportNamesLazy).forEach(
+    ({ filePath, pageFile, globValue }) => {
+      pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+      const loadModule = globValue;
+      assertLoadModule(loadModule);
+      pageFile.loadExportNames = async () => {
+        if (!("exportNames" in pageFile)) {
+          const moduleExports = await loadModule();
+          assert(
+            hasProp(moduleExports, "exportNames", "string[]"),
+            pageFile.filePath,
+          );
+          pageFile.exportNames = moduleExports.exportNames;
+        }
+      };
+    },
+  );
+
+  const createPageFileObject = (filePath: string) => {
+    const fileType = filePath.includes(".page.") ? "page" : "config";
+    return {
+      filePath,
+      fileType,
+      isEnv: false,
+      isRelevant: true,
+      isDefaultPageFile: false,
+      isRendererPageFile: false,
+      pageId: filePath,
+      loadExportNames: () => {},
+      isErrorPageFile: false,
+    } as unknown as PageFile;
+  };
+
+  pageFilesExports.pageFilesList.forEach((filePath) => {
+    pageFilesMap[filePath] =
+      pageFilesMap[filePath] ?? createPageFileObject(filePath);
+  });
+
+  const pageFiles = Object.values(pageFilesMap);
+  pageFiles.forEach(({ filePath }) => {
+    assert(!filePath.includes("\\"));
+  });
+
+  return { pageFiles, pageConfigs, pageConfigGlobal };
+}
+
+type GlobResult = {
+  filePath: string;
+  pageFile: PageFile;
+  globValue: unknown;
+}[];
+function parseGlobResult(globObject: Record<string, unknown>): GlobResult {
+  const ret: GlobResult = [];
+  Object.entries(globObject).forEach(([fileType, globFiles]) => {
+    assertCast<string>(fileType);
+    assert(fileType === "page" || fileType === "config");
+    assert(isObject(globFiles));
+    Object.entries(globFiles).forEach(([filePath, globValue]) => {
+      const pageFile = createPageFileObject(filePath);
+      assert(
+        (fileType === "page" && pageFile.fileType.startsWith(".page")) ||
+          (fileType === "config" && pageFile.fileType.startsWith(".config")),
+      );
+      ret.push({ filePath, pageFile, globValue });
+    });
+  });
+  return ret;
+}
+
+function assertLoadModule(
+  globValue: unknown,
+): asserts globValue is () => Promise<Record<string, unknown>> {
+  assert(isCallable(globValue));
+}
+
+function assertPageConfigsSerialized(
+  pageConfigsSerialized: unknown,
+): asserts pageConfigsSerialized is PageConfigRuntimeSerialized[] {
+  assert(isArray(pageConfigsSerialized));
+  pageConfigsSerialized.forEach((pageConfigSerialized) => {
+    assert(isObject(pageConfigSerialized));
+    assert(hasProp(pageConfigSerialized, "pageId", "string"));
+    assert(hasProp(pageConfigSerialized, "routeFilesystem"));
+    assert(hasProp(pageConfigSerialized, "configValuesSerialized"));
+  });
+}
+
+function assertPageConfigGlobalSerialized(
+  pageConfigGlobalSerialized: unknown,
+): asserts pageConfigGlobalSerialized is PageConfigGlobalRuntimeSerialized {
+  assert(hasProp(pageConfigGlobalSerialized, "configValuesSerialized"));
+}

package/dist/core/processing/getters/getPageFiles/setPageFiles.ts

@@ -0,0 +1,76 @@
+export { getPageFilesAll, setPageFiles, setPageFilesAsync };
+
+import type {
+  PageConfigGlobalRuntime,
+  PageConfigRuntime,
+} from "../../../../types/interfaces/page.js";
+
+import { parseGlobResults } from "./parseGlobResults.js";
+import { assert } from "../../../gaurds/assertions/assert/index.js";
+import getGlobalObject from "../getGlobalObject.js";
+import { unique } from "../../../utils/index.js";
+import { PageFile } from "../../../__internal/index.js";
+
+const globalObject = getGlobalObject<{
+  pageFilesAll?: PageFile[] | undefined;
+  pageConfigs?: PageConfigRuntime[] | undefined;
+  pageConfigGlobal?: PageConfigGlobalRuntime | undefined;
+  pageFilesGetter?: () => Promise<void> | undefined;
+}>("setPageFiles.ts", {});
+
+// TODO:v1-design-release: rename setPageFiles() getPageFilesAll() parseGlobResult()
+function setPageFiles(pageFilesExports: unknown) {
+  const { pageFiles, pageConfigs, pageConfigGlobal } =
+    parseGlobResults(pageFilesExports);
+  globalObject.pageFilesAll = pageFiles;
+  globalObject.pageConfigs = pageConfigs;
+  globalObject.pageConfigGlobal = pageConfigGlobal;
+}
+function setPageFilesAsync(getPageFilesExports: () => Promise<unknown>) {
+  globalObject.pageFilesGetter = async () => {
+    setPageFiles(await getPageFilesExports());
+  };
+}
+
+async function getPageFilesAll(
+  isClientSide: boolean,
+  isProduction?: boolean,
+): Promise<{
+  pageFilesAll: PageFile[];
+  allPageIds: string[];
+  pageConfigs: PageConfigRuntime[];
+  pageConfigGlobal: PageConfigGlobalRuntime;
+}> {
+  if (isClientSide) {
+    assert(!globalObject.pageFilesGetter);
+    assert(isProduction === undefined);
+  } else {
+    assert(globalObject.pageFilesGetter);
+    assert(typeof isProduction === "boolean");
+    if (
+      !globalObject.pageFilesAll ||
+      // We reload all glob imports in dev to make auto-reload work
+      !isProduction
+    ) {
+      await globalObject.pageFilesGetter();
+    }
+  }
+  const { pageFilesAll, pageConfigs, pageConfigGlobal } = globalObject;
+  assert(pageFilesAll && pageConfigs && pageConfigGlobal);
+  const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+  return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal };
+}
+
+function getAllPageIds(
+  allPageFiles: PageFile[],
+  pageConfigs: PageConfigRuntime[],
+): string[] {
+  const fileIds = allPageFiles
+    .filter(({ isDefaultPageFile }) => !isDefaultPageFile)
+    .map(({ pageId }) => pageId);
+  const allPageIds = unique(fileIds);
+
+  const allPageIds2 = pageConfigs.map((p) => p.pageId);
+
+  return [...allPageIds, ...allPageIds2];
+}

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

@@ -0,0 +1,87 @@
+// TODO/pageContext-prefetch: rename this file to getPrefetchSettingResolved.ts
+
+export { getPrefetchSettings, PAGE_CONTEXT_MAX_AGE_DEFAULT };
+export type { PrefetchSettingResolved };
+
+import type { PrefetchSetting } from "../../../types/interfaces/node.js";
+import { assertInfoLog } from "../../gaurds/assertions/assertInfo/log.js";
+import { PageContextExports } from "./getPageFiles/index.js";
+
+// TODO/pageContext-prefetch: Make it `Infinity` for pre-rendered pages.
+const PAGE_CONTEXT_MAX_AGE_DEFAULT = 5000;
+const prefetchSettingTrue = {
+  staticAssets: "hover",
+  pageContext: PAGE_CONTEXT_MAX_AGE_DEFAULT,
+} satisfies PrefetchSettingResolved;
+const prefetchSettingFalse = {
+  staticAssets: "hover",
+  pageContext: false,
+} satisfies PrefetchSettingResolved;
+
+const prefetchSettingDefault = prefetchSettingTrue;
+
+type PrefetchSettingResolved = {
+  staticAssets: false | "hover" | "viewport";
+  pageContext: false | number;
+};
+
+function getPrefetchSettings(
+  pageContext: PageContextExports,
+  linkTag: null | HTMLElement,
+): PrefetchSettingResolved {
+  let prefetchSetting: PrefetchSettingResolved = prefetchSettingDefault;
+
+  if ("prefetch" in pageContext) {
+    const { prefetch } = pageContext;
+    if (prefetch === true) prefetchSetting = prefetchSettingTrue;
+    if (prefetch === false) prefetchSetting = prefetchSettingFalse;
+    // No validation in order to save client-side KBs
+    Object.assign(prefetchSetting, prefetch);
+    if (
+      (prefetchSetting as Exclude<PrefetchSetting, boolean>).pageContext ===
+      true
+    ) {
+      prefetchSetting.pageContext = PAGE_CONTEXT_MAX_AGE_DEFAULT;
+    }
+  }
+
+  if (prefetchSetting.staticAssets === "viewport" && import.meta.env.DEV) {
+    assertInfoLog(false, "Viewport prefetching is disabled in development", {
+      onlyOnce: true,
+    });
+    prefetchSetting.staticAssets = "hover";
+  }
+
+  if (linkTag) {
+    {
+      let attr = linkTag.getAttribute("data-prefetch");
+      if (attr !== null) {
+        if (attr === "") attr = "true";
+        if (attr === "true") prefetchSetting = prefetchSettingTrue;
+        if (attr === "false") prefetchSetting = prefetchSettingFalse;
+      }
+    }
+    {
+      let attr = linkTag.getAttribute("data-prefetch-static-assets");
+      if (attr !== null) {
+        if (attr === "false") prefetchSetting.staticAssets = false;
+        // No validation in order to save client-side KBs
+        prefetchSetting.staticAssets = attr as "hover" | "viewport";
+      }
+    }
+    {
+      let attr = linkTag.getAttribute("data-prefetch-page-context");
+      if (attr !== null) {
+        if (attr === "") attr = "true";
+        if (attr === "true")
+          prefetchSetting.pageContext = PAGE_CONTEXT_MAX_AGE_DEFAULT;
+        if (attr === "false") prefetchSetting.pageContext = false;
+        const n = parseInt(attr, 10);
+        if (!Number.isNaN(n)) prefetchSetting.pageContext = n;
+        // No validation in order to save client-side KBs
+      }
+    }
+  }
+
+  return prefetchSetting;
+}

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

@@ -0,0 +1,18 @@
+import { createErrorWithCleanStackTrace } from "../../gaurds/errors/createErrorWithCleanStackTrace";
+import { numberOfStackTraceLinesToRemove } from "../../globals/logger/numberOfStackTraceLinesToRemove";
+import { addPrefixAssertType } from "../../globals/tags/addPrefixAssertType";
+import { addPrefixProjectName } from "../../globals/tags/addPrefixProjectName";
+import { addWhitespace } from "../../utils/string/addWhitespace";
+
+export { getProjectError };
+
+function getProjectError(errMsg: string) {
+  errMsg = addWhitespace(errMsg);
+  errMsg = addPrefixAssertType(errMsg, "Error");
+  errMsg = addPrefixProjectName(errMsg);
+  const projectError = createErrorWithCleanStackTrace(
+    errMsg,
+    numberOfStackTraceLinesToRemove,
+  );
+  return projectError;
+}

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

@@ -0,0 +1,10 @@
+export function getPropAccessNotation(
+  key: unknown,
+): `.${string}` | `[${string}]` {
+  return typeof key === "string" && isKeyDotNotationCompatible(key)
+    ? `.${key}`
+    : `[${JSON.stringify(key)}]`;
+}
+function isKeyDotNotationCompatible(key: string): boolean {
+  return /^[a-z0-9\$_]+$/i.test(key);
+}

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

@@ -0,0 +1,15 @@
+import { assert } from "../../gaurds/assertions/assert";
+
+export { getRandomId };
+
+// https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
+
+function getRandomId(length: number): string {
+  let randomId = "";
+  while (randomId.length < length) {
+    randomId += Math.random().toString(36).slice(2);
+  }
+  randomId = randomId.slice(0, length);
+  assert(/^[a-z0-9]+$/.test(randomId) && randomId.length === length);
+  return randomId;
+}

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

@@ -0,0 +1,5 @@
+const getRevalidationKey = () => {
+  return process.env.PAYLOAD_REVALIDATION_KEY;
+};
+
+export default getRevalidationKey;

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

@@ -0,0 +1,7 @@
+export function getRevealClientEntry(isClientRouting: boolean): string {
+  if (isClientRouting) {
+    return "/path/to/client-entry-client-routing.js";
+  } else {
+    return "/path/to/client-entry.js";
+  }
+}