camox 0.47.0 → 0.51.0

package/dist/features/runtime/runtimeRoutes.d.ts

@@ -11,6 +11,7 @@ export declare const RUNTIME_ROUTE_PATHS: {
   readonly health: "/_camox/health";
   readonly registry: "/_camox/registry";
   readonly routes: "/_camox/routes";
+  readonly logo: "/_camox/logo.png";
   readonly og: "/og";
   readonly sitemap: "/sitemap.xml";
   readonly "llms-txt": "/llms.txt";

package/dist/features/runtime/runtimeRoutes.js

@@ -11,6 +11,7 @@ const RUNTIME_ROUTE_PATHS = {
 	health: "/_camox/health",
 	registry: "/_camox/registry",
 	routes: "/_camox/routes",
+	logo: "/_camox/logo.png",
 	og: "/og",
 	sitemap: "/sitemap.xml",
 	"llms-txt": "/llms.txt"

package/dist/features/runtime/structuredData.js

@@ -0,0 +1,213 @@
+import { isArticle, isCreativeWork, isWebPageKind } from "../../core/structuredData.js";
+import { isPageUrlMarker, linkedRecordId } from "@camox/api-contract";
+import { createSchemaOrgGraph, defineBreadcrumb, defineOrganization, defineWebPage, defineWebSite } from "@unhead/schema-org";
+
+//#region src/features/runtime/structuredData.ts
+/**
+* A value of a node the API evaluated, with the absolute URL of each page its markers name.
+* Only the runtime knows the website's address.
+*/
+function withPageUrls(value, pageUrl) {
+	if (isPageUrlMarker(value)) return pageUrl(value);
+	if (Array.isArray(value)) return value.map((entry) => withPageUrls(entry, pageUrl));
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, withPageUrls(entry, pageUrl)]));
+	return value;
+}
+/** The `@id`s of the site's nodes, derived from the website's address. */
+function siteNodeIds(siteUrl) {
+	return {
+		organization: `${siteUrl}#identity`,
+		website: `${siteUrl}#website`
+	};
+}
+/** The Organization publishing the website, and the WebSite itself. */
+function siteNodes(site, inLanguage) {
+	const ids = siteNodeIds(site.url);
+	return [defineOrganization({
+		"@id": ids.organization,
+		name: site.name,
+		url: site.url,
+		logo: {
+			url: site.logo.url,
+			width: site.logo.width,
+			height: site.logo.height
+		},
+		...site.socialProfiles.length > 0 && { sameAs: [...site.socialProfiles] }
+	}), defineWebSite({
+		"@id": ids.website,
+		name: site.name,
+		url: site.url,
+		inLanguage,
+		publisher: { "@id": ids.organization }
+	})];
+}
+/** The `@id`s of a page's nodes, derived from its URL. */
+function pageNodeIds(pageUrl) {
+	return {
+		page: `${pageUrl}#webpage`,
+		mainEntity: `${pageUrl}#main-entity`
+	};
+}
+/**
+* The page's own node, part of the WebSite, of the kind its layout says, or a plain WebPage,
+* linking its main entity and the records it mentions.
+*/
+function pageNode(page, site, declared, { mainEntity, mentions }) {
+	const kind = declared && isWebPageKind(declared) ? declared : void 0;
+	return defineWebPage({
+		...kind,
+		"@type": kind?.["@type"] ?? "WebPage",
+		"@id": pageNodeIds(page.url).page,
+		url: page.url,
+		name: page.name,
+		...page.description && { description: page.description },
+		inLanguage: page.inLanguage,
+		isPartOf: { "@id": siteNodeIds(site.url).website },
+		...page.image && { primaryImageOfPage: { url: page.image } },
+		...page.datePublished && { datePublished: page.datePublished.toISOString() },
+		...page.dateModified && { dateModified: page.dateModified.toISOString() },
+		...mainEntity && { mainEntity: { "@id": mainEntity } },
+		...mentions.length > 0 && { mentions: mentions.map((id) => ({ "@id": id })) }
+	});
+}
+/**
+* The thing a page is about, as its own node, filled from the page where its layout leaves
+* properties out: its name or headline, description, URL and image for every type, and its
+* dates, publisher and language for creative works.
+*/
+function mainEntityNode(entity, page, site, id) {
+	const work = isCreativeWork(entity);
+	return {
+		...isArticle(entity) ? { headline: page.name } : { name: page.name },
+		...page.description && { description: page.description },
+		url: page.url,
+		...page.image && { image: page.image },
+		...work && {
+			...page.datePublished && { datePublished: page.datePublished.toISOString() },
+			...page.dateModified && { dateModified: page.dateModified.toISOString() },
+			publisher: { "@id": siteNodeIds(site.url).organization },
+			inLanguage: page.inLanguage
+		},
+		...entity,
+		"@id": id,
+		mainEntityOfPage: { "@id": pageNodeIds(page.url).page }
+	};
+}
+/** The page's breadcrumb, which the page node links. None for a page without crumbs. */
+function breadcrumbNodes(page) {
+	if (!page.breadcrumb?.length) return [];
+	return [defineBreadcrumb({
+		"@id": `${page.url}#breadcrumb`,
+		itemListElement: page.breadcrumb.map((crumb) => ({
+			name: crumb.name,
+			item: crumb.url
+		}))
+	})];
+}
+/**
+* The things the page's blocks show, each its own node, linked to the page: creative works are
+* part of it, and it is about anything else. Every placement's nodes have their own `@id`s.
+*/
+function blockNodes(page, blocks = []) {
+	const pageId = { "@id": pageNodeIds(page.url).page };
+	return blocks.flatMap(({ id, nodes }) => nodes.map((node, index) => ({
+		...node,
+		"@id": `${page.url}#block-${id}-${index}`,
+		[isCreativeWork(node) ? "isPartOf" : "subjectOf"]: pageId
+	})));
+}
+/**
+* The records a graph places: links to records with nodes become their `@id`s and place the
+* records, and links to records without nodes read as their titles, or are left out.
+*/
+function recordPlacement(records) {
+	const placed = /* @__PURE__ */ new Set();
+	const pending = [];
+	const place = (id) => {
+		if (placed.has(id)) return;
+		placed.add(id);
+		pending.push(id);
+	};
+	const link = (value) => {
+		const id = linkedRecordId(value);
+		if (id !== void 0) {
+			if (!records?.nodes[id]) return records?.titles?.[id];
+			place(id);
+			return { "@id": records.id(id) };
+		}
+		if (Array.isArray(value)) return value.map(link).filter((entry) => entry !== void 0);
+		if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).flatMap(([key, entry]) => {
+			const linked = link(entry);
+			return linked === void 0 ? [] : [[key, linked]];
+		}));
+		return value;
+	};
+	return {
+		placed,
+		place,
+		/** A value with its links resolved. */
+		link: (value) => link(value),
+		/** The nodes of the records placed since last asked, and of those they link in turn. */
+		nodes: () => {
+			const nodes = [];
+			for (let id = pending.shift(); id !== void 0; id = pending.shift()) {
+				const { "@id": _own, ...node } = records.nodes[id];
+				nodes.push({
+					...link(node),
+					"@id": records.id(id)
+				});
+			}
+			return nodes;
+		}
+	};
+}
+/** Every node a page's graph holds, before they are resolved and linked. */
+function graphNodes({ site, page, declared, blocks, records }) {
+	const placement = recordPlacement(records);
+	const linked = declared && placement.link(declared);
+	const blockList = blockNodes(page, blocks).map(placement.link);
+	const mainRecord = !declared && records?.main && records.nodes[records.main] && records.main;
+	let mainEntity;
+	if (linked && !isWebPageKind(linked)) mainEntity = mainEntityNode(linked, page, site, pageNodeIds(page.url).mainEntity);
+	if (mainRecord) placement.place(mainRecord);
+	const placedRecords = placement.nodes();
+	if (mainRecord) {
+		const index = placedRecords.findIndex((node) => node["@id"] === records.id(mainRecord));
+		const [node] = placedRecords.splice(index, 1);
+		mainEntity = mainEntityNode(node, page, site, records.id(mainRecord));
+	}
+	const mentions = (records?.referenced ?? []).filter((id) => records.nodes[id] && !placement.placed.has(id));
+	for (const id of mentions) placement.place(id);
+	const recordNodes = [...placedRecords, ...placement.nodes()];
+	return [
+		...siteNodes(site, page.inLanguage),
+		pageNode(page, site, linked, {
+			mainEntity: mainEntity?.["@id"],
+			mentions: mentions.map((id) => records.id(id))
+		}),
+		...mainEntity ? [mainEntity] : [],
+		...breadcrumbNodes(page),
+		...blockList,
+		...recordNodes
+	];
+}
+/** A page's graph, resolved into JSON-LD. */
+function buildPageGraph(input) {
+	const graph = createSchemaOrgGraph();
+	graph.push(graphNodes(input));
+	return {
+		"@context": "https://schema.org",
+		"@graph": graph.resolveGraph({
+			host: input.site.url,
+			url: input.page.url,
+			inLanguage: input.page.inLanguage
+		})
+	};
+}
+/** JSON-LD as a script's text: `<` is escaped, so content can't close the script. */
+function serializeStructuredData(data) {
+	return JSON.stringify(data).replaceAll("<", "\\u003c");
+}
+
+//#endregion
+export { buildPageGraph, serializeStructuredData, siteNodeIds, withPageUrls };

package/dist/features/runtime/worker.d.ts

@@ -1,6 +1,10 @@
 //#region src/features/runtime/worker.d.ts
+/** What the Worker gets with each request: only `waitUntil` matters here. */
+interface WorkerContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
 declare const _default: {
-  fetch(request: Request): Promise<Response>;
+  fetch(request: Request, _env?: unknown, context?: WorkerContext): Promise<Response>;
 };
 //#endregion
 export { _default as default };

package/dist/features/runtime/worker.js

@@ -1,6 +1,7 @@
 import { fetchLocalhostOnLoopback } from "./loopbackFetch.js";
+import { readLiveCacheKey, respondThroughPublicCache } from "./publicCache.js";
 import { shouldHandleRequest, withDevHtml } from "./workerRequest.js";
-import { devHtml, handleCamoxRequest, runtimeBasePath } from "virtual:camox/server";
+import { devHtml, handleCamoxRequest, isPublicRequest, publicCacheSource, runtimeBasePath } from "virtual:camox/server";
 
 //#region src/features/runtime/worker.ts
 /**
@@ -12,9 +13,25 @@ if (devHtml) globalThis.fetch = fetchLocalhostOnLoopback(globalThis.fetch.bind(g
 function notFound() {
 	return new Response("Not found", { status: 404 });
 }
-var worker_default = { async fetch(request) {
+/**
+* Answers a request, from the edge cache when every visitor sees the same. Dev renders the
+* developer's development draft, which nothing shares, and a Worker calling this one without
+* its context can't keep anything past the response.
+*/
+function respond(request, context) {
+	const cache = globalThis.caches?.default;
+	if (devHtml || !context || !cache || !isPublicRequest(request)) return handleCamoxRequest(request);
+	const { apiUrl, projectUuid, build } = publicCacheSource;
+	return respondThroughPublicCache(request, {
+		cache,
+		liveCacheKey: () => readLiveCacheKey(apiUrl, projectUuid),
+		build,
+		waitUntil: (promise) => context.waitUntil(promise)
+	}, () => handleCamoxRequest(request));
+}
+var worker_default = { async fetch(request, _env, context) {
 	if (!shouldHandleRequest(request, runtimeBasePath)) return notFound();
-	const response = await handleCamoxRequest(request);
+	const response = await respond(request, context);
 	if (!response) return notFound();
 	return withDevHtml(response, devHtml);
 } };