@janga/norna 0.7.17 → 0.7.22

package/src/lib/sitePages.ts

@@ -1,10 +1,16 @@
 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 = {
+	kind: 'category' | 'page';
 	isHome: boolean;
 	navigation: {
 		listed: boolean;
@@ -13,8 +19,7 @@ export type SitePage = {
 	depth: number;
 	pageDirectories: string[];
 	pathSegment: string;
-	pathname: string;
-	pageDirectory: string | null;
+	pageDirectory: string;
 	pageId: string;
 	pageIds: string[];
 	pageOrders: number[];
@@ -23,6 +28,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) => {
@@ -37,13 +57,17 @@ const stripPageIdPrefix = (id: string) => {
 	}
 };
 
-export const isHomePageEntry = (entry: SiteEntry) => stripPageIdPrefix(entry.id) === null;
+export const isHomePageEntry = (entry: SiteEntry) => stripPageIdPrefix(entry.id) === homePageDirectory;
 
-const getPageDirectory = (entry: SiteEntry) => isHomePageEntry(entry) ? null : stripPageIdPrefix(entry.id);
+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;
+};
 
 const getPageMetadata = (entry: SiteEntry) => {
 	const pageDirectory = getPageDirectory(entry);
-	return pageDirectory ? parsePageDirectoryPath(pageDirectory, `page directory ${pageDirectory}`) : null;
+	return parsePageDirectoryPath(pageDirectory, `page directory ${pageDirectory}`);
 };
 
 const getPagePathname = (pathSegment: string) => pathSegment ? `/${pathSegment}/` : '/';
@@ -58,60 +82,85 @@ 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 pageDirectory = pageMetadata?.pageDirectory ?? null;
-	const pageId = pageMetadata?.pageId ?? '';
-	const pagePath = pageMetadata?.pagePath ?? '';
+	const { body, contentLabel, markdownDocument } = await readPageMarkdownDocument(entry);
+	const pageDirectory = pageMetadata.pageDirectory;
+	const pageId = pageMetadata.pageId;
+	const pagePath = pageMetadata.pagePath;
 	const pathSegment = isHome ? '' : pagePath;
 	const navigation = entry.data.navigation ?? {};
 
 	return {
+		kind: 'page',
 		entry,
 		isHome,
-		depth: pageMetadata?.depth ?? 0,
+		depth: pageMetadata.depth,
 		navigation: {
 		listed: navigation.listed ?? true,
-			order: isHome ? 0 : pageMetadata?.pageOrder ?? 100,
+			order: isHome ? 0 : pageMetadata.pageOrder,
 		},
 		pathSegment,
 		pathname: getPagePathname(pathSegment),
 		pageDirectory,
-		pageDirectories: pageMetadata?.pageDirectories ?? [],
+		pageDirectories: pageMetadata.pageDirectories,
 		pageId,
-		pageIds: pageMetadata?.pageIds ?? [],
-		pageOrders: pageMetadata?.pageOrders ?? [],
+		pageIds: pageMetadata.pageIds,
+		pageOrders: pageMetadata.pageOrders,
 		pagePath,
-		parentPagePath: pageMetadata?.parentPagePath ?? null,
-		title: getPageTitle(entry),
+		parentPagePath: isHome ? null : pageMetadata.parentPagePath,
+		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 => ({
+	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>();
 
 	for (const page of pages) {
+		if (page.isHome && page.navigation.listed === false) {
+			throw new Error(`${homePageDirectory} is the required homepage and cannot set navigation.listed to false.`);
+		}
 		const existing = pathnames.get(page.pathname);
 		if (existing) {
 			throw new Error(`Duplicate page path "${page.pathname}" from "${existing.entry.id}" and "${page.entry.id}".`);
@@ -121,7 +170,7 @@ export const getSitePages = (entries: SiteEntry[]) => {
 
 		if (page.isHome) continue;
 
-		const siblingScope = page.parentPagePath ?? '';
+		const siblingScope = page.pageDirectories.slice(0, -1).join('/pages/');
 		const pageIdKey = `${siblingScope}\0${page.pageId}`;
 		const existingPageId = siblingPageIds.get(pageIdKey);
 		if (existingPageId) {
@@ -138,6 +187,9 @@ export const getSitePages = (entries: SiteEntry[]) => {
 
 		siblingPageOrders.set(pageOrderKey, page);
 	}
+	if (!pages.some(({ isHome }) => isHome)) {
+		throw new Error(`Homepage page entry ${homePageDirectory} is missing.`);
+	}
 
 	return pages.sort((left, right) => (
 		left.isHome ? -1 : right.isHome ? 1 :
@@ -146,3 +198,33 @@ 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,
+	};
+};
+
+export const getSitePages = async (entries: SiteEntry[]) => (await getSiteModel(entries)).pages;

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

@@ -5,7 +5,7 @@ import { getSitePage, getSitePages, isHomePageEntry } from '../lib/sitePages';
 
 export async function getStaticPaths() {
 	const entries = await getCollection('site');
-	const pages = getSitePages(entries);
+	const pages = await getSitePages(entries);
 
 	return pages
 		.filter((page) => !page.isHome)
@@ -21,7 +21,7 @@ if (!entry || isHomePageEntry(entry)) {
 	throw new Error('Page entry is missing.');
 }
 
-const currentPage = getSitePage(entry);
+const currentPage = await getSitePage(entry);
 
 if (!currentPage.pathSegment) {
 	throw new Error(`Page "${entry.id}" needs a page id.`);

package/src/pages/index.astro

@@ -2,9 +2,10 @@
 import { getCollection } from 'astro:content';
 import SitePage from '../components/SitePage.astro';
 import { isHomePageEntry } from '../lib/sitePages';
+import { homePageDirectory } from '../../scripts/lib/site-conventions.mjs';
 
 const siteDirectory = (process.env.NORNA_SITE_DIR ?? 'site').trim();
-const siteContentLabel = `${siteDirectory || 'site'}/content.md`;
+const siteContentLabel = `${siteDirectory || 'site'}/pages/${homePageDirectory}/content.md`;
 const entries = await getCollection('site');
 const site = entries.find(isHomePageEntry);