@janga/norna 0.7.22 → 0.7.23

package/scripts/lib/content-sync-plan.mjs

@@ -0,0 +1,179 @@
+import path from 'node:path';
+
+import { toPosixPath } from './site-content.mjs';
+
+export const getExpectedImagePath = (contentFile, imageName) =>
+	path.join(contentFile.imagesDir, imageName);
+
+export const getExpectedImageLabel = (contentFile, imageName) =>
+	`${contentFile.imagesLabel}/${imageName}`;
+
+export const getImageRootLabel = (contentFile) => contentFile.imagesLabel.replace(/\/images$/, '');
+
+export const getImageCandidateLabel = ({ contentFile, imagePath }) =>
+	`${contentFile.imagesLabel}/${toPosixPath(path.relative(contentFile.imagesDir, imagePath))}`;
+
+const getReferenceLabel = (contentFile, section) =>
+	`${contentFile.contentLabel} [${section.id ?? 'page title'}]`;
+
+const addMapEntry = (map, key, value) => {
+	if (!map.has(key)) map.set(key, []);
+	map.get(key).push(value);
+};
+
+const addReferenceIssue = (issues, entry, issue) => {
+	issues.push({ ...entry, issue, phase: 'reference' });
+};
+
+const addConflictIssue = (issues, move, issue) => {
+	issues.push({
+		contentFile: move.contentFile,
+		section: move.section,
+		reference: move.reference,
+		issue,
+		phase: 'conflict',
+	});
+};
+
+const addMoveConflicts = (moves, issues) => {
+	const movesBySource = new Map();
+	const movesByDestination = new Map();
+
+	for (const move of moves) {
+		addMapEntry(movesBySource, move.from, move);
+		addMapEntry(movesByDestination, move.to, move);
+	}
+
+	for (const sourceMoves of movesBySource.values()) {
+		const destinations = new Set(sourceMoves.map((move) => move.to));
+		if (destinations.size <= 1) continue;
+
+		const firstMove = sourceMoves[0];
+		addConflictIssue(issues, firstMove, {
+			severity: 'error',
+			message: `Cannot relocate "${firstMove.imageName}" because the same source file is referenced from multiple destinations: ${sourceMoves.map((move) => getExpectedImageLabel(move.contentFile, move.imageName)).join(', ')}.`,
+			fix: 'Duplicate the image manually or rename one of the image files so each move has a single destination.',
+		});
+	}
+
+	for (const destinationMoves of movesByDestination.values()) {
+		const sources = new Set(destinationMoves.map((move) => move.from));
+		if (sources.size <= 1) continue;
+
+		const firstMove = destinationMoves[0];
+		addConflictIssue(issues, firstMove, {
+			severity: 'error',
+			message: `Cannot relocate "${firstMove.imageName}" because multiple source files would move to ${getExpectedImageLabel(firstMove.contentFile, firstMove.imageName)}: ${destinationMoves.map((move) => getImageCandidateLabel({ contentFile: move.sourceContentFile, imagePath: move.from })).join(', ')}.`,
+			fix: 'Move the intended file manually or rename files so the destination is unambiguous.',
+		});
+	}
+};
+
+export const createImageSyncPlan = ({
+	imageCandidates,
+	references,
+	reportMisplaced,
+}) => {
+	const candidatesByName = new Map();
+	const expectedReferencesByPath = new Map();
+	const issues = [];
+	const moves = [];
+	const referencedImagePaths = new Set();
+	const resolvedPathByReference = new Map();
+
+	for (const candidate of imageCandidates) {
+		addMapEntry(candidatesByName, candidate.imageName, candidate);
+	}
+
+	for (const candidates of candidatesByName.values()) {
+		candidates.sort((left, right) => left.imagePath.localeCompare(right.imagePath, 'sv'));
+	}
+
+	for (const entry of references) {
+		const expectedPath = getExpectedImagePath(entry.contentFile, entry.reference.image);
+		addMapEntry(expectedReferencesByPath, expectedPath, entry);
+	}
+
+	for (const entry of references) {
+		const { contentFile, reference, section } = entry;
+		const imageName = reference.image;
+		const expectedPath = getExpectedImagePath(contentFile, imageName);
+		const expectedLabel = getExpectedImageLabel(contentFile, imageName);
+		const candidates = (candidatesByName.get(imageName) ?? [])
+			.filter(({ imagePath }) => imagePath !== expectedPath);
+		const expectedCandidate = (candidatesByName.get(imageName) ?? [])
+			.find(({ imagePath }) => imagePath === expectedPath);
+
+		if (expectedCandidate) {
+			referencedImagePaths.add(expectedPath);
+			resolvedPathByReference.set(reference, expectedPath);
+			continue;
+		}
+
+		if (candidates.length === 0) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Image "${imageName}" does not exist at ${expectedLabel} or anywhere under any page image root.`,
+				fix: `Add the source image directly to ${contentFile.imagesLabel}/ or remove the Norna-managed image reference.`,
+			});
+			continue;
+		}
+
+		if (candidates.length > 1) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Cannot relocate "${imageName}". Multiple files with this filename were found: ${candidates.map(getImageCandidateLabel).join(', ')}.`,
+				fix: 'Move the intended file manually or rename files so the move is unambiguous.',
+			});
+			continue;
+		}
+
+		const sourceCandidate = candidates[0];
+		const sourcePath = sourceCandidate.imagePath;
+		const referencesAtCurrentLocation = (expectedReferencesByPath.get(sourcePath) ?? [])
+			.filter((expectedReference) => expectedReference.contentFile !== contentFile);
+
+		if (referencesAtCurrentLocation.length > 0) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Cannot relocate "${imageName}" from ${getImageCandidateLabel(sourceCandidate)} because it is still referenced from ${referencesAtCurrentLocation.map((expectedReference) => getReferenceLabel(expectedReference.contentFile, expectedReference.section)).join(', ')}.`,
+				fix: 'Remove the extra reference, duplicate the image file manually, or rename one of the image files so the intended move is unambiguous.',
+			});
+			continue;
+		}
+
+		if (!moves.some((move) => move.from === sourcePath && move.to === expectedPath)) {
+			moves.push({
+				imageName,
+				from: sourcePath,
+				to: expectedPath,
+				contentFile,
+				sourceContentFile: sourceCandidate.contentFile,
+				section,
+				reference,
+			});
+		}
+
+		referencedImagePaths.add(sourcePath);
+		resolvedPathByReference.set(reference, sourcePath);
+
+		if (reportMisplaced) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Image "${imageName}" is used here but is located in ${getImageCandidateLabel(sourceCandidate)}.`,
+				fix: sourceCandidate.contentFile === contentFile
+					? 'Run norna content:sync to move it directly into the current page image root.'
+					: `Run norna content:sync to move it from ${getImageRootLabel(sourceCandidate.contentFile)} to ${getImageRootLabel(contentFile)}.`,
+			});
+		}
+	}
+
+	addMoveConflicts(moves, issues);
+
+	return {
+		issues,
+		moves,
+		referencedImagePaths,
+		resolvedPathByReference,
+	};
+};

package/scripts/lib/editor-language-service.mjs

@@ -5,9 +5,11 @@ import {
 	getOpenMarkdownFenceAtLine,
 	nornaMarkdownBlockDefinitions,
 } from './norna-markdown-blocks.mjs';
+import { resolveNavigationModel } from './navigation-model.mjs';
 import { inspectPublicAssetFilenames, logoAssetFilenames } from './public-asset-conventions.mjs';
 import { parsePageMarkdownSource } from './page-markdown.mjs';
 import { siteSchema } from './schema-definitions.mjs';
+import { homePageDirectory } from './site-conventions.mjs';
 
 const supportedImageExtensions = new Set(['.jpg', '.jpeg', '.png', '.svg']);
 const siteConfigNames = ['config.yaml'];
@@ -33,6 +35,132 @@ export const findNornaSiteRoot = async (documentPath) => {
 	}
 };
 
+const readEditorYaml = async (filePath) => {
+	try {
+		const source = await readFile(filePath, 'utf8');
+		const data = load(source) ?? {};
+		return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+	} catch {
+		return null;
+	}
+};
+
+const readContentFrontmatterForEditor = (source) => {
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+	if (!match) return {};
+	try {
+		const data = load(match[1]) ?? {};
+		return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+	} catch {
+		return {};
+	}
+};
+
+const getNavigationNodesForEditor = async (siteRoot) => {
+	const nodes = [];
+
+	const visit = async (pagesDirectory, depth = 1) => {
+		const entries = (await readdir(pagesDirectory, { withFileTypes: true }).catch((error) => {
+			if (error?.code === 'ENOENT') return [];
+			throw error;
+		}))
+			.filter((entry) => entry.isDirectory())
+			.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+
+		for (const entry of entries) {
+			const nodeDirectory = path.join(pagesDirectory, entry.name);
+			const contentPath = path.join(nodeDirectory, 'content.md');
+			const categoryPath = path.join(nodeDirectory, 'category.yaml');
+			const [hasContent, hasCategory] = await Promise.all([
+				fileExists(contentPath),
+				fileExists(categoryPath),
+			]);
+
+			if (hasContent !== hasCategory) {
+				if (hasCategory) {
+					nodes.push({
+						depth,
+						headings: [],
+						isHome: false,
+						kind: 'category',
+						listed: true,
+					});
+				} else {
+					const source = await readFile(contentPath, 'utf8');
+					const data = readContentFrontmatterForEditor(source);
+					const document = await parsePageMarkdownSource(source, { label: contentPath });
+					nodes.push({
+						depth,
+						headings: document.navigationHeadings,
+						isHome: depth === 1 && entry.name === homePageDirectory,
+						kind: 'page',
+						listed: data.navigation?.listed !== false,
+					});
+				}
+			}
+
+			await visit(path.join(nodeDirectory, 'pages'), depth + 1);
+		}
+	};
+
+	await visit(path.join(siteRoot, 'pages'));
+	return nodes;
+};
+
+const getNavigationModeForEditor = async (siteRoot) => {
+	const config = await readEditorYaml(path.join(siteRoot, 'config.yaml'));
+	if (!config) return null;
+	const requestedMode = config.navigation?.mode ?? 'automatic';
+	if (requestedMode !== 'automatic') return requestedMode;
+
+	try {
+		return resolveNavigationModel({
+			mode: requestedMode,
+			nodes: await getNavigationNodesForEditor(siteRoot),
+		}).mode;
+	} catch {
+		return null;
+	}
+};
+
+const findNestedYamlPropertyLine = (source, parentKey, propertyKey) => {
+	const lines = source.replace(/\r\n?/g, '\n').split('\n');
+	let insideParent = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (new RegExp(`^${parentKey}:\\s*(?:#.*)?$`).test(line)) {
+			insideParent = true;
+			continue;
+		}
+		if (!insideParent) continue;
+		if (/^[A-Za-z][A-Za-z0-9-]*:/.test(line)) return 1;
+		if (new RegExp(`^  ${propertyKey}:`).test(line)) return index + 1;
+	}
+	return 1;
+};
+
+export const getThemeDiagnostics = async ({ documentPath, source }) => {
+	let theme;
+	try {
+		theme = load(source) ?? {};
+	} catch {
+		return [];
+	}
+	if (!theme || typeof theme !== 'object' || Array.isArray(theme)) return [];
+
+	const backgroundPattern = theme.sections?.backgroundPattern;
+	if (backgroundPattern === undefined || backgroundPattern === 'uniform') return [];
+	const siteRoot = await findNornaSiteRoot(documentPath);
+	if (!siteRoot || await getNavigationModeForEditor(siteRoot) !== 'tree') return [];
+
+	return [{
+		code: 'tree-section-background-pattern',
+		line: findNestedYamlPropertyLine(source, 'sections', 'backgroundPattern'),
+		message: `sections.backgroundPattern "${backgroundPattern}" cannot be used because this site resolves to tree navigation. Tree navigation uses one uniform reading surface so the navigation rail and page content remain distinct. Remove sections.backgroundPattern or set it to uniform.`,
+		severity: 'error',
+	}];
+};
+
 const readSitewideLogoForEditor = async (siteRoot) => {
 	const filename = await findFile(siteRoot, ['sitewide-content.yaml']);
 	if (!filename) return null;

package/scripts/lib/heading-ids.mjs

@@ -79,7 +79,7 @@ export const getMarkdownHeadings = async (source) => {
 			),
 		}));
 
-	return { headings, source: normalizedSource };
+	return { headings, source: normalizedSource, tree };
 };
 
 export const getHeadingIdentifierIssues = (headings) => {

package/scripts/lib/image-presentation.mjs

@@ -0,0 +1,2 @@
+export const imagePresentationNames = Object.freeze(['prose-aligned', 'centered-fit']);
+export const defaultImagePresentation = 'prose-aligned';

package/scripts/lib/markdown-links.mjs

@@ -0,0 +1,182 @@
+const getNodeRange = (node) => {
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	return Number.isInteger(start) && Number.isInteger(end)
+		? { start, end }
+		: null;
+};
+
+const visitNodes = (node, visit) => {
+	if (!node || typeof node !== 'object') return;
+	visit(node);
+	if (!Array.isArray(node.children)) return;
+	for (const child of node.children) visitNodes(child, visit);
+};
+
+const scanDestination = (source, start, end) => {
+	let cursor = start;
+	while (cursor < end && /\s/.test(source[cursor] ?? '')) cursor += 1;
+
+	if (source[cursor] === '<') {
+		const targetStart = cursor + 1;
+		for (cursor = targetStart; cursor < end; cursor += 1) {
+			if (source[cursor] === '>' && source[cursor - 1] !== '\\') {
+				return { start: targetStart, end: cursor };
+			}
+		}
+		return null;
+	}
+
+	const targetStart = cursor;
+	let parenthesisDepth = 0;
+	let escaped = false;
+	for (; cursor < end; cursor += 1) {
+		const character = source[cursor] ?? '';
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (character === '\\') {
+			escaped = true;
+			continue;
+		}
+		if (character === '(') {
+			parenthesisDepth += 1;
+			continue;
+		}
+		if (character === ')') {
+			if (parenthesisDepth === 0) break;
+			parenthesisDepth -= 1;
+			continue;
+		}
+		if (/\s/.test(character) && parenthesisDepth === 0) break;
+	}
+
+	return { start: targetStart, end: cursor };
+};
+
+const getInlineLinkTargetRange = (source, node) => {
+	const nodeRange = getNodeRange(node);
+	if (!nodeRange) return null;
+	const childEnd = Array.isArray(node.children)
+		? Math.max(nodeRange.start, ...node.children.map((child) => child.position?.end.offset ?? nodeRange.start))
+		: nodeRange.start;
+	const delimiter = source.indexOf('](', childEnd);
+	if (delimiter < 0 || delimiter >= nodeRange.end) return null;
+	return scanDestination(source, delimiter + 2, nodeRange.end);
+};
+
+const getDefinitionTargetRange = (source, node) => {
+	const nodeRange = getNodeRange(node);
+	if (!nodeRange) return null;
+	const delimiter = source.indexOf(']:', nodeRange.start);
+	if (delimiter < 0 || delimiter >= nodeRange.end) return null;
+	return scanDestination(source, delimiter + 2, nodeRange.end);
+};
+
+const getSourceTarget = (source, range, fallback) => range
+	? source.slice(range.start, range.end)
+	: fallback;
+
+export const extractMarkdownLinks = ({ source, tree, lineOffset = 0 }) => {
+	const definitions = new Map();
+	visitNodes(tree, (node) => {
+		if (node.type !== 'definition') return;
+		definitions.set(node.identifier, node);
+	});
+
+	const links = [];
+	visitNodes(tree, (node) => {
+		if (node.type === 'link') {
+			const range = getNodeRange(node);
+			const targetRange = getInlineLinkTargetRange(source, node);
+			links.push({
+				kind: 'markdown-link',
+				column: node.position?.start.column ?? 1,
+				line: lineOffset + (node.position?.start.line ?? 1),
+				range,
+				target: node.url ?? '',
+				targetRange,
+				targetSource: getSourceTarget(source, targetRange, node.url ?? ''),
+			});
+			return;
+		}
+
+		if (node.type !== 'linkReference') return;
+		const definition = definitions.get(node.identifier);
+		if (!definition) return;
+		const targetRange = getDefinitionTargetRange(source, definition);
+		links.push({
+			kind: 'markdown-reference-link',
+			column: node.position?.start.column ?? 1,
+			definitionLine: lineOffset + (definition.position?.start.line ?? 1),
+			line: lineOffset + (node.position?.start.line ?? 1),
+			range: getNodeRange(node),
+			target: definition.url ?? '',
+			targetRange,
+			targetSource: getSourceTarget(source, targetRange, definition.url ?? ''),
+		});
+	});
+
+	return links;
+};
+
+const getLineOffsets = (source) => {
+	const offsets = [0];
+	for (let index = 0; index < source.length; index += 1) {
+		if (source[index] === '\n') offsets.push(index + 1);
+	}
+	return offsets;
+};
+
+const getCardLinkTargetRange = (source, lineStart) => {
+	const lineEnd = source.indexOf('\n', lineStart);
+	const end = lineEnd < 0 ? source.length : lineEnd;
+	const line = source.slice(lineStart, end);
+	const match = line.match(/^\s*link:\s*(.*?)\s*$/);
+	if (!match) return null;
+
+	const value = match[1] ?? '';
+	let valueStart = lineStart + (match.index ?? 0) + match[0].indexOf(value);
+	let valueEnd = valueStart + value.length;
+	if (
+		value.length >= 2
+		&& (value[0] === '"' || value[0] === "'")
+		&& value.at(-1) === value[0]
+	) {
+		valueStart += 1;
+		valueEnd -= 1;
+	}
+
+	return { start: valueStart, end: valueEnd };
+};
+
+export const extractNornaBlockLinks = ({ source, blocks, lineOffset = 0 }) => {
+	const lineOffsets = getLineOffsets(source);
+	const links = [];
+
+	for (const block of blocks) {
+		if (block.type !== 'card-list') continue;
+		for (const card of block.cards) {
+			if (!card.link || !card.linkLine) continue;
+			const localLine = card.linkLine - lineOffset;
+			const lineStart = lineOffsets[localLine - 1];
+			const targetRange = Number.isInteger(lineStart)
+				? getCardLinkTargetRange(source, lineStart)
+				: null;
+			links.push({
+				kind: 'card-link',
+				column: targetRange && Number.isInteger(lineStart)
+					? targetRange.start - lineStart + 1
+					: 3,
+				line: card.linkLine,
+				range: targetRange,
+				target: card.link,
+				targetRange,
+				targetSource: getSourceTarget(source, targetRange, card.link),
+			});
+		}
+	}
+
+	return links;
+};

package/scripts/lib/navigation-model.mjs

@@ -15,26 +15,35 @@ const assertNavigationMode = (mode) => {
 
 const getListedNodes = (nodes) => nodes.filter((node) => node.isHome || node.listed !== false);
 
-const getNodeNavigationDepth = (node) => {
-	const nodeDepth = node.depth ?? 1;
-	return (node.headings ?? []).reduce((maximum, heading) => (
-		Math.max(maximum, nodeDepth + heading.depth - 1)
-	), nodeDepth);
+const getNodeDepth = (node) => node.depth ?? 1;
+
+const getTopLevelPagePath = (pagePath) => pagePath?.split('/')[0] ?? '';
+
+const branchNeedsPageRail = (nodes, pagePath) => {
+	const rootPath = getTopLevelPagePath(pagePath);
+	if (!rootPath) return false;
+
+	return nodes.some((node) => (
+		(node.pagePath === rootPath && node.kind === 'category')
+		|| node.pagePath?.startsWith(`${rootPath}/`)
+	));
 };
 
-export const getAutomaticNavigationMode = (nodes) => {
+export const getAutomaticNavigationMode = (nodes, currentPage = null) => {
 	const listedNodes = getListedNodes(nodes);
 	if (listedNodes.length <= 1) return 'sections';
-	if (listedNodes.some((node) => node.kind === 'category')) return 'tree';
 
-	const maximumDepth = listedNodes.reduce((maximum, node) => (
-		Math.max(maximum, getNodeNavigationDepth(node))
-	), 1);
+	if (currentPage) {
+		if (currentPage.isHome) return 'top';
+		return branchNeedsPageRail(listedNodes, currentPage.pagePath) ? 'tree' : 'top';
+	}
 
-	return maximumDepth <= 2 ? 'top' : 'tree';
+	return listedNodes.some((node) => node.kind === 'category' || getNodeDepth(node) > 1)
+		? 'tree'
+		: 'top';
 };
 
-export const resolveNavigationModel = ({ mode = 'automatic', nodes }) => {
+export const resolveNavigationModel = ({ mode = 'automatic', nodes, currentPage = null }) => {
 	const requestedMode = assertNavigationMode(mode);
 	const listedNodes = getListedNodes(nodes);
 	const hasCategories = listedNodes.some((node) => node.kind === 'category');
@@ -42,16 +51,18 @@ export const resolveNavigationModel = ({ mode = 'automatic', nodes }) => {
 		throw new Error(`Navigation categories require tree navigation. Remove navigation.mode: ${requestedMode}, or set navigation.mode: tree.`);
 	}
 	const maximumDepth = listedNodes.reduce((maximum, node) => (
-		Math.max(maximum, getNodeNavigationDepth(node))
+		Math.max(maximum, getNodeDepth(node))
 	), 1);
+	const hasNestedPages = listedNodes.some((node) => getNodeDepth(node) > 1);
 
 	return Object.freeze({
 		mode: requestedMode === 'automatic'
-			? getAutomaticNavigationMode(listedNodes)
+			? getAutomaticNavigationMode(listedNodes, currentPage)
 			: requestedMode,
 		requestedMode,
 		listedNodeCount: listedNodes.length,
 		hasCategories,
+		hasNestedPages,
 		maximumDepth,
 	});
 };

package/scripts/lib/norna-markdown-blocks.mjs

@@ -495,6 +495,7 @@ const parseCardListBlock = (source, options = {}) => {
 		}
 
 		current[entry.key] = entry.value;
+		if (entry.key === 'link') current.linkLine = lineNumber;
 	}
 
 	for (const card of cards) {