@janga/norna 0.7.18 → 0.7.23

package/src/lib/sitePages.ts

@@ -1,11 +1,17 @@
 import type { CollectionEntry } from 'astro:content';
+import path from 'node:path';
 import { decodePageDirectoryPath, parsePageDirectoryPath } from '../../scripts/lib/page-model.mjs';
+import { parsePageMarkdown } from '../../scripts/lib/page-markdown.mjs';
+import { readSiteFile } from '../../scripts/lib/site-content.mjs';
 import { homePageDirectory } from '../../scripts/lib/site-conventions.mjs';
+import { getSiteStructure } from '../../scripts/lib/site-structure.mjs';
+import { sitePagesDir, sitePagesLabel } from '../../scripts/lib/site-paths.mjs';
 
 type SiteEntry = CollectionEntry<'site'>;
 
-export type SitePage = {
-	entry: SiteEntry;
+type SiteNodeBase = {
+	aliases: string[];
+	kind: 'category' | 'page';
 	isHome: boolean;
 	navigation: {
 		listed: boolean;
@@ -14,7 +20,6 @@ export type SitePage = {
 	depth: number;
 	pageDirectories: string[];
 	pathSegment: string;
-	pathname: string;
 	pageDirectory: string;
 	pageId: string;
 	pageIds: string[];
@@ -24,6 +29,21 @@ export type SitePage = {
 	title: string;
 };
 
+export type SitePage = SiteNodeBase & {
+	kind: 'page';
+	entry: SiteEntry;
+	pathname: string;
+	markdown: string;
+	markdownDocument: Awaited<ReturnType<typeof parsePageMarkdown>>;
+	contentLabel: string;
+};
+
+export type SiteCategory = SiteNodeBase & {
+	kind: 'category';
+};
+
+export type SiteNode = SitePage | SiteCategory;
+
 const pageIdMarker = '-page-';
 
 const stripPageIdPrefix = (id: string) => {
@@ -40,7 +60,7 @@ const stripPageIdPrefix = (id: string) => {
 
 export const isHomePageEntry = (entry: SiteEntry) => stripPageIdPrefix(entry.id) === homePageDirectory;
 
-const getPageDirectory = (entry: SiteEntry) => {
+export const getPageDirectory = (entry: SiteEntry) => {
 	const pageDirectory = stripPageIdPrefix(entry.id);
 	if (!pageDirectory) throw new Error(`Page entry "${entry.id}" has no valid page directory.`);
 	return pageDirectory;
@@ -63,26 +83,23 @@ const compareNumberPaths = (left: number[], right: number[]) => {
 	return left.length - right.length;
 };
 
-const decodeHtmlEntities = (value: string) => value
-	.replace(/&amp;/g, '&')
-	.replace(/&lt;/g, '<')
-	.replace(/&gt;/g, '>')
-	.replace(/&quot;/g, '"')
-	.replace(/&#39;/g, "'");
-
-const getPageTitle = (entry: SiteEntry) => {
-	const html = entry.rendered?.html ?? '';
-	const headings = Array.from(html.matchAll(/<h1\b[^>]*>([\s\S]*?)<\/h1>/gi));
-	if (headings.length !== 1) {
+const readPageMarkdownDocument = async (entry: SiteEntry) => {
+	const pageDirectory = getPageDirectory(entry);
+	const contentLabel = `${sitePagesLabel}/${pageDirectory}/content.md`;
+	const { body } = await readSiteFile(path.join(sitePagesDir, pageDirectory, 'content.md'), contentLabel);
+	const markdownDocument = await parsePageMarkdown(body, { label: contentLabel });
+
+	if (markdownDocument.pageHeadings.length !== 1 || markdownDocument.regions[0]?.kind !== 'page-intro') {
 		throw new Error(`Page entry "${entry.id}" must contain exactly one Markdown H1 page title.`);
 	}
 
-	return decodeHtmlEntities((headings[0]?.[1] ?? '').replace(/<[^>]*>/g, '')).trim();
+	return { body, contentLabel, markdownDocument };
 };
 
-export const getSitePage = (entry: SiteEntry): SitePage => {
+const createSitePage = async (entry: SiteEntry): Promise<SitePage> => {
 	const isHome = isHomePageEntry(entry);
 	const pageMetadata = getPageMetadata(entry);
+	const { body, contentLabel, markdownDocument } = await readPageMarkdownDocument(entry);
 	const pageDirectory = pageMetadata.pageDirectory;
 	const pageId = pageMetadata.pageId;
 	const pagePath = pageMetadata.pagePath;
@@ -90,6 +107,8 @@ export const getSitePage = (entry: SiteEntry): SitePage => {
 	const navigation = entry.data.navigation ?? {};
 
 	return {
+		aliases: entry.data.page?.aliases ?? [],
+		kind: 'page',
 		entry,
 		isHome,
 		depth: pageMetadata.depth,
@@ -106,12 +125,37 @@ export const getSitePage = (entry: SiteEntry): SitePage => {
 		pageOrders: pageMetadata.pageOrders,
 		pagePath,
 		parentPagePath: isHome ? null : pageMetadata.parentPagePath,
-		title: getPageTitle(entry),
+		contentLabel,
+		markdown: body,
+		markdownDocument,
+		title: markdownDocument.pageTitle.title,
 	};
 };
 
-export const getSitePages = (entries: SiteEntry[]) => {
-	const pages = entries.map(getSitePage);
+const createSiteCategory = (category: Awaited<ReturnType<typeof getSiteStructure>>['categories'][number]): SiteCategory => ({
+	aliases: [],
+	kind: 'category',
+	isHome: false,
+	depth: category.depth,
+	navigation: {
+		listed: true,
+		order: category.pageOrder,
+	},
+	pathSegment: category.pagePath,
+	pageDirectory: category.pageDirectory,
+	pageDirectories: category.pageDirectories,
+	pageId: category.pageId,
+	pageIds: category.pageIds,
+	pageOrders: category.pageOrders,
+	pagePath: category.pagePath,
+	parentPagePath: category.parentPagePath,
+	title: category.label,
+});
+
+export const getSitePage = async (entry: SiteEntry): Promise<SitePage> => createSitePage(entry);
+
+const createSitePages = async (entries: SiteEntry[]) => {
+	const pages = await Promise.all(entries.map(createSitePage));
 	const pathnames = new Map<string, SitePage>();
 	const siblingPageIds = new Map<string, SitePage>();
 	const siblingPageOrders = new Map<string, SitePage>();
@@ -157,3 +201,31 @@ export const getSitePages = (entries: SiteEntry[]) => {
 		left.pathname.localeCompare(right.pathname, 'sv')
 	));
 };
+
+export const getSiteModel = async (entries: SiteEntry[]) => {
+	const [pages, structure] = await Promise.all([
+		createSitePages(entries),
+		getSiteStructure(),
+	]);
+	const pagesByDirectory = new Map(pages.map((page) => [page.pageDirectory, page]));
+	const nodes = structure.nodes.map((node): SiteNode => {
+		if (node.kind === 'category') return createSiteCategory(node);
+
+		const page = pagesByDirectory.get(node.pageDirectory);
+		if (!page) {
+			throw new Error(`${node.contentLabel} was discovered as a page but Astro did not load it.`);
+		}
+		return page;
+	});
+
+	if (pagesByDirectory.size !== structure.contentFiles.length) {
+		throw new Error('Astro loaded a page that is outside the validated Norna page structure.');
+	}
+
+	return {
+		categories: nodes.filter((node): node is SiteCategory => node.kind === 'category'),
+		nodes,
+		pages,
+		warnings: structure.warnings,
+	};
+};

package/src/pages/[...slug].astro

@@ -1,31 +1,58 @@
 ---
 import { getCollection } from 'astro:content';
+import { assertPageAliasModel, createPageAliasModel } from '../../scripts/lib/page-aliases.mjs';
+import { getSitePublicFiles } from '../../scripts/lib/site-link-graph.mjs';
+import PageAliasRedirect from '../components/PageAliasRedirect.astro';
 import SitePage from '../components/SitePage.astro';
-import { getSitePage, getSitePages, isHomePageEntry } from '../lib/sitePages';
+import { getSiteModel, getSitePage, isHomePageEntry } from '../lib/sitePages';
 
 export async function getStaticPaths() {
 	const entries = await getCollection('site');
-	const pages = getSitePages(entries);
+	const siteModel = await getSiteModel(entries);
+	const aliasModel = assertPageAliasModel(createPageAliasModel({
+		categories: siteModel.categories,
+		pages: siteModel.pages,
+		publicFiles: await getSitePublicFiles(),
+	}));
+	const pagesByPathname = new Map(siteModel.pages.map((page) => [page.pathname, page]));
 
-	return pages
+	const pagePaths = siteModel.pages
 		.filter((page) => !page.isHome)
 		.map((page) => ({
 			params: { slug: page.pathSegment },
 			props: { entry: page.entry },
 		}));
+	const aliasPaths = aliasModel.aliases.map((alias) => {
+		const page = pagesByPathname.get(alias.targetPathname);
+		if (!page) throw new Error(`Page alias "${alias.pathname}" has no target page ${alias.targetPathname}.`);
+
+		return {
+			params: { slug: alias.pathname.slice(1, -1) },
+			props: {
+				alias: {
+					targetPathname: page.pathname,
+					targetTitle: page.title,
+				},
+			},
+		};
+	});
+
+	return [...pagePaths, ...aliasPaths];
 }
 
-const { entry } = Astro.props;
+const { alias, entry } = Astro.props;
 
-if (!entry || isHomePageEntry(entry)) {
+if (!alias && (!entry || isHomePageEntry(entry))) {
 	throw new Error('Page entry is missing.');
 }
 
-const currentPage = getSitePage(entry);
+const currentPage = entry ? await getSitePage(entry) : null;
 
-if (!currentPage.pathSegment) {
+if (!alias && !currentPage?.pathSegment) {
 	throw new Error(`Page "${entry.id}" needs a page id.`);
 }
 ---
 
-<SitePage entry={entry} />
+{alias
+	? <PageAliasRedirect targetPathname={alias.targetPathname} targetTitle={alias.targetTitle} />
+	: <SitePage entry={entry} />}