@revealui/core 0.0.1-pre.0

package/dist/core/renderer/page/inferMediaType.ts

@@ -0,0 +1,128 @@
+export { inferMediaType };
+export type { MediaType };
+
+import { isScriptFile, styleFileRE } from "../stream/utils.js";
+
+type MediaType = null | {
+  // List of `as` values: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+  assetType:
+    | "image"
+    | "script"
+    | "font"
+    | "style"
+    | "audio"
+    | "video"
+    | "document"
+    | "fetch"
+    | "track"
+    | "worker"
+    | "embed"
+    | "object";
+  mediaType:
+    | "text/javascript"
+    | "text/css"
+    | "image/avif"
+    | "image/jpeg"
+    | "image/png"
+    | "image/webp"
+    | "image/gif"
+    | "image/svg+xml"
+    | "font/ttf"
+    | "font/woff"
+    | "font/woff2"
+    | "video/mp4"
+    | "video/webm"
+    | "video/ogg"
+    | "video/mpeg"
+    | "video/x-msvideo"
+    | "video/quicktime"
+    | "audio/mpeg"
+    | "audio/wav"
+    | "audio/ogg"
+    | "audio/aac"
+    | "audio/midi"
+    | "audio/flac";
+};
+
+function inferMediaType(href: string): MediaType {
+  // Basics
+  if (styleFileRE.test(href)) {
+    return { mediaType: "text/css", assetType: "style" };
+  }
+  if (isScriptFile(href)) {
+    return { mediaType: "text/javascript", assetType: "script" };
+  }
+
+  // Images
+  if (href.endsWith(".png")) {
+    return { assetType: "image", mediaType: "image/png" };
+  }
+  if (href.endsWith(".webp")) {
+    return { assetType: "image", mediaType: "image/webp" };
+  }
+  if (href.endsWith(".jpg") || href.endsWith(".jpeg")) {
+    return { assetType: "image", mediaType: "image/jpeg" };
+  }
+  if (href.endsWith(".gif")) {
+    return { assetType: "image", mediaType: "image/gif" };
+  }
+  if (href.endsWith(".svg")) {
+    return { assetType: "image", mediaType: "image/svg+xml" };
+  }
+  if (href.endsWith(".avif")) {
+    return { assetType: "image", mediaType: "image/avif" };
+  }
+
+  // Fonts
+  if (href.endsWith(".ttf")) {
+    return { assetType: "font", mediaType: "font/ttf" };
+  }
+  if (href.endsWith(".woff")) {
+    return { assetType: "font", mediaType: "font/woff" };
+  }
+  if (href.endsWith(".woff2")) {
+    return { assetType: "font", mediaType: "font/woff2" };
+  }
+
+  // Videos
+  if (href.endsWith(".mp4")) {
+    return { assetType: "video", mediaType: "video/mp4" };
+  }
+  if (href.endsWith(".webm")) {
+    return { assetType: "video", mediaType: "video/webm" };
+  }
+  if (href.endsWith(".ogv")) {
+    return { assetType: "video", mediaType: "video/ogg" };
+  }
+  if (href.endsWith(".mpeg") || href.endsWith(".mpg")) {
+    return { assetType: "video", mediaType: "video/mpeg" };
+  }
+  if (href.endsWith(".avi")) {
+    return { assetType: "video", mediaType: "video/x-msvideo" };
+  }
+  if (href.endsWith(".mov") || href.endsWith(".qt")) {
+    return { assetType: "video", mediaType: "video/quicktime" };
+  }
+
+  // Audios
+  if (href.endsWith(".mp3")) {
+    return { assetType: "audio", mediaType: "audio/mpeg" };
+  }
+  if (href.endsWith(".wav")) {
+    return { assetType: "audio", mediaType: "audio/wav" };
+  }
+  if (href.endsWith(".ogg")) {
+    return { assetType: "audio", mediaType: "audio/ogg" };
+  }
+  if (href.endsWith(".m4a")) {
+    return { assetType: "audio", mediaType: "audio/aac" };
+  }
+  if (href.endsWith("midi") || href.endsWith(".mid")) {
+    return { assetType: "audio", mediaType: "audio/midi" };
+  }
+  if (href.endsWith(".flac")) {
+    return { assetType: "audio", mediaType: "audio/flac" };
+  }
+
+  return null;
+}

package/dist/core/renderer/page/loadUserFilesServerSide.ts

@@ -0,0 +1,154 @@
+export { loadUserFilesServerSide };
+export type { PageContext_loadUserFilesServerSide, PageFiles };
+
+import type { PromiseType } from "../../../types/interfaces/logic.js";
+import type { PageConfigRuntime } from "../../../types/interfaces/page.js";
+import type { PageFile } from "../../__internal/index.js";
+import { findPageConfig } from "../../config/findPageConfig.js";
+import { loadConfigValues } from "../../config/loadConfigValues.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js";
+import {
+	debugPageFiles,
+	type PageContextDebugRouteMatches,
+} from "../../gaurds/debugger/debugPageFiles.js";
+import { getGlobalContext } from "../../globals/contexts/globalContext/index.js";
+import {
+	getPageAssets,
+	type PageAsset,
+	type PageContextGetPageAssets,
+} from "../../processing/getters/getPageAssets.js";
+import {
+	getPageContextExports,
+	getPageFilesAll,
+} from "../../processing/getters/getPageFiles/index.js";
+import { analyzePage } from "../../processing/iterators/analyzePage.js";
+import {
+	hasProp,
+	isArray,
+	isArrayOfStrings,
+	objectAssign,
+} from "../stream/utils.js";
+
+type PageContext_loadUserFilesServerSide = PageContextGetPageAssets &
+	PageContextDebugRouteMatches & {
+		urlOriginal: string;
+		_pageFilesAll: PageFile[];
+		_pageConfigs: PageConfigRuntime[];
+	};
+type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
+async function loadUserFilesServerSide(
+	pageContext: { pageId: string } & PageContext_loadUserFilesServerSide,
+) {
+	const pageConfig = findPageConfig(
+		pageContext._pageConfigs,
+		pageContext.pageId,
+	); // Make pageConfig globally available as pageContext._pageConfig?
+
+	const [loadPageUserFilesResult] = await Promise.allSettled([
+		loadPageUserFiles(
+			pageContext._pageFilesAll,
+			pageConfig,
+			pageContext.pageId,
+			!getGlobalContext().isProduction,
+		),
+	]);
+
+	if (loadPageUserFilesResult.status !== "fulfilled") {
+		throw new Error("Failed to load page user files");
+	}
+
+	const { pageFilesLoaded, pageContextExports } = loadPageUserFilesResult.value;
+	const {
+		isHtmlOnly,
+		isClientRouting,
+		clientEntries,
+		clientDependencies,
+		pageFilesClientSide,
+		pageFilesServerSide,
+	} = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext.pageId);
+	const isV1Design = !!pageConfig;
+
+	const passToClient: string[] = [];
+	const errMsg = " should be an array of strings.";
+	if (!isV1Design) {
+		pageContextExports.sources.passToClient?.forEach((e) => {
+			assertUsage(hasProp(e, "exportValue", "string[]"), `${e}${errMsg}`);
+			passToClient.push(...e.exportValue);
+		});
+	} else {
+		pageContextExports.sources.passToClient?.forEach((e) => {
+			assertUsage(hasProp(e, "exportValue"), `${e}${errMsg}`);
+			const { exportValue } = e as { exportValue: unknown };
+			assert(isArray(exportValue));
+			const vals = exportValue.flat(1);
+			assertUsage(isArrayOfStrings(vals), `${e}${errMsg}`);
+			passToClient.push(...vals);
+		});
+	}
+
+	const pageContextAddendum = {};
+	objectAssign(pageContextAddendum, pageContextExports);
+	objectAssign(pageContextAddendum, {
+		Page: pageContextExports,
+		_isHtmlOnly: isHtmlOnly,
+		_passToClient: passToClient,
+		_pageFilePathsLoaded: pageFilesLoaded.pageFilesAll.map(
+			(p: { filePath: string }) => p.filePath,
+		),
+	});
+
+	objectAssign(pageContextAddendum, {
+		__getPageAssets: async () => {
+			if ("_pageAssets" in pageContext) {
+				return (pageContext as any as { _pageAssets: PageAsset[] })._pageAssets;
+			} else {
+				const pageAssets = await getPageAssets(
+					pageContext,
+					clientDependencies,
+					clientEntries,
+				);
+				objectAssign(pageContext, { _pageAssets: pageAssets });
+				return pageContext._pageAssets;
+			}
+		},
+	});
+	debugPageFiles({
+		pageContext,
+		isHtmlOnly,
+		isClientRouting,
+		pageFilesLoaded: pageFilesLoaded.pageFilesAll,
+		pageFilesClientSide,
+		pageFilesServerSide,
+		clientEntries,
+		clientDependencies,
+	});
+
+	return pageContextAddendum;
+}
+
+async function loadPageUserFiles(
+	pageFilesAll: PageFile[],
+	pageConfig: null | PageConfigRuntime,
+	pageId: string,
+	isDev: boolean,
+) {
+	const pageFilesServerSide = await getPageFilesAll(
+		false,
+		getGlobalContext().isProduction,
+	);
+
+	const pageConfigLoaded = !pageConfig
+		? null
+		: await loadConfigValues(pageConfig, isDev);
+	await Promise.allSettled(
+		pageFilesServerSide.pageFilesAll.map((p: PageFile) =>
+			p.loadFile ? p.loadFile() : Promise.resolve(),
+		),
+	);
+	const pageContextExports = getPageContextExports(pageConfigLoaded);
+	return {
+		pageContextExports,
+		pageFilesLoaded: pageFilesServerSide,
+	};
+}

package/dist/core/renderer/page/preparePageContextForUserConsumption.ts

@@ -0,0 +1,55 @@
+export { preparePageContextForUserConsumption };
+
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { assertWarning } from "../../gaurds/assertions/assertWarning/index.js";
+import { addIs404ToPageProps } from "../../processing/setters/addIs404ToPageProps.js";
+import type { PageContextForUserConsumptionClientSide } from "../../targets/client/preparePageContextForUserConsumptionClientSide.js";
+import { compareString } from "../../utils/string/compareString.js";
+import type { PageContextForUserConsumptionServerSide } from "./preparePageContextForUserConsumptionServerSide.js";
+
+type PageContextForUserConsumption =
+  | PageContextForUserConsumptionServerSide
+  | PageContextForUserConsumptionClientSide;
+
+function preparePageContextForUserConsumption(
+  pageContext: PageContextForUserConsumption,
+) {
+  assert(pageContext.pageId);
+  assert("config" in pageContext);
+  assert("configEntries" in pageContext);
+
+  addIs404ToPageProps(pageContext);
+
+  // TODO/next-major-release: remove
+  if (!("_pageId" in pageContext)) {
+    Object.defineProperty(pageContext, "_pageId", {
+      get() {
+        assertWarning(
+          false,
+          "pageContext._pageId has been renamed to pageContext.pageId",
+          {
+            showStackTrace: true,
+            onlyOnce: true,
+          },
+        );
+        return pageContext.pageId;
+      },
+      enumerable: false,
+    });
+  }
+
+  // For a more readable `console.log(pageContext)` output
+  sortPageContext(pageContext);
+}
+
+// Sort `pageContext` keys alphabetically, in order to make reading the `console.log(pageContext)` output easier
+function sortPageContext(pageContext: Record<string, unknown>): void {
+  let descriptors = Object.getOwnPropertyDescriptors(pageContext);
+  for (const key of Object.keys(pageContext)) delete pageContext[key];
+  descriptors = Object.fromEntries(
+    Object.entries(descriptors).sort(([key1], [key2]) =>
+      compareString(key1, key2),
+    ),
+  );
+  Object.defineProperties(pageContext, descriptors);
+}

package/dist/core/renderer/page/preparePageContextForUserConsumptionServerSide.ts

@@ -0,0 +1,38 @@
+export { preparePageContextForUserConsumptionServerSide };
+export type { PageContextForUserConsumptionServerSide };
+
+import { PageContextBuiltInServerInternal } from "../../../types/interfaces/context.js";
+import { PageConfigRuntime } from "../../../types/interfaces/page.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { isPlainObject } from "../../gaurds/validators/isPlainObject.js";
+import {
+  assertPageContextUrl,
+  PageContextUrlInternal,
+} from "../../processing/getters/getPageContextUrlComputed.js";
+import type { PageContextExports } from "../../processing/getters/getPageFiles/getExports.js";
+import { preparePageContextForUserConsumption } from "./preparePageContextForUserConsumption.js";
+
+type PageContextForUserConsumptionServerSide =
+  PageContextBuiltInServerInternal &
+    PageContextExports & {
+      urlOriginal: string;
+      urlPathname: string;
+      urlParsed: PageContextUrlInternal["urlParsed"];
+      routeParams: Record<string, string>;
+      Page: unknown;
+      pageId: string;
+      _pageConfigs: PageConfigRuntime[];
+      is404: null | boolean;
+      isClientSideNavigation: boolean;
+      pageProps?: Record<string, unknown>;
+    } & Record<string, unknown>;
+
+function preparePageContextForUserConsumptionServerSide(
+  pageContext: PageContextForUserConsumptionServerSide,
+): void {
+  assertPageContextUrl(pageContext);
+  assert(isPlainObject(pageContext.routeParams));
+  assert("Page" in pageContext);
+  assert(typeof pageContext.isClientSideNavigation === "boolean");
+  preparePageContextForUserConsumption(pageContext);
+}