@janga/norna 0.7.18 → 0.7.23

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

@@ -13,39 +13,56 @@ const assertNavigationMode = (mode) => {
 	return mode;
 };
 
-const getListedPages = (pages) => pages.filter((page) => page.isHome || page.listed !== false);
+const getListedNodes = (nodes) => nodes.filter((node) => node.isHome || node.listed !== false);
 
-const getPageNavigationDepth = (page) => {
-	const pageDepth = page.depth ?? 1;
-	return (page.headings ?? []).reduce((maximum, heading) => (
-		Math.max(maximum, pageDepth + heading.depth - 1)
-	), pageDepth);
+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 = (pages) => {
-	const listedPages = getListedPages(pages);
-	if (listedPages.length <= 1) return 'sections';
+export const getAutomaticNavigationMode = (nodes, currentPage = null) => {
+	const listedNodes = getListedNodes(nodes);
+	if (listedNodes.length <= 1) return 'sections';
 
-	const maximumDepth = listedPages.reduce((maximum, page) => (
-		Math.max(maximum, getPageNavigationDepth(page))
-	), 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', pages }) => {
+export const resolveNavigationModel = ({ mode = 'automatic', nodes, currentPage = null }) => {
 	const requestedMode = assertNavigationMode(mode);
-	const listedPages = getListedPages(pages);
-	const maximumDepth = listedPages.reduce((maximum, page) => (
-		Math.max(maximum, getPageNavigationDepth(page))
+	const listedNodes = getListedNodes(nodes);
+	const hasCategories = listedNodes.some((node) => node.kind === 'category');
+	if (hasCategories && requestedMode !== 'automatic' && requestedMode !== 'tree') {
+		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, getNodeDepth(node))
 	), 1);
+	const hasNestedPages = listedNodes.some((node) => getNodeDepth(node) > 1);
 
 	return Object.freeze({
 		mode: requestedMode === 'automatic'
-			? getAutomaticNavigationMode(listedPages)
+			? getAutomaticNavigationMode(listedNodes, currentPage)
 			: requestedMode,
 		requestedMode,
-		listedPageCount: listedPages.length,
+		listedNodeCount: listedNodes.length,
+		hasCategories,
+		hasNestedPages,
 		maximumDepth,
 	});
 };

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'node:buffer';
 import { documentationLink } from './documentation-links.mjs';
 
 const field = (description, options = {}) => Object.freeze({ description, ...options });
@@ -55,13 +54,12 @@ export const nornaMarkdownBlockDefinitions = Object.freeze({
 					xl: value('Extra large', 'Use the largest card and image size.'),
 				}),
 			}),
-			width: field('Limit the width of the complete card list. Defaults to normal.', {
-				default: 'normal',
+			width: field('Override the root theme\'s maximum width for this card list.', {
 				values: Object.freeze({
-					text: value('Text', 'Match the active body-text width.'),
-					narrow: value('Narrow', 'Use a narrow card-list width.'),
-					normal: value('Normal', 'Use the balanced default card-list width.'),
-					wide: value('Wide', 'Allow the card list to use more horizontal space.'),
+					text: value('Text', 'Match the active body-text width, including a reader-selected reading width.'),
+					narrow: value('Narrow', 'Limit the complete card list to at most 48rem.'),
+					normal: value('Normal', 'Limit the complete card list to at most 56rem.'),
+					wide: value('Wide', 'Allow the complete card list to use the available page-layout width.'),
 				}),
 			}),
 		}),
@@ -87,7 +85,6 @@ const blockTypeLabels = {
 
 const knownBlockTypeList = Array.from(nornaBlockTypes).join(', ');
 const imageNameRegex = /^[a-z0-9][a-z0-9.-]*\.(jpe?g|png|svg)$/i;
-const markerTagName = 'norna-block';
 const imageStackExample = [
 	'```norna-image-stack',
 	'- image: filename.jpg',
@@ -98,7 +95,6 @@ const cardListExample = [
 	'layout: image-top',
 	'flow: grid',
 	'size: m',
-	'width: normal',
 	'',
 	'- title: Adopt',
 	'  text: Give a dog a new home.',
@@ -203,6 +199,35 @@ const getFenceCloseInfo = (line, opening) => {
 	return fence;
 };
 
+export const getOpenMarkdownFenceAtLine = (markdown, lineIndex) => {
+	const lines = normalizeLines(markdown);
+	let open = null;
+
+	for (let index = 0; index <= Math.min(lineIndex, lines.length - 1); index += 1) {
+		const fence = getFenceInfo(lines[index]);
+		if (!fence || fence.length < 3) continue;
+
+		if (!open) {
+			open = {
+				character: fence.markerCharacter,
+				length: fence.length,
+				line: index,
+				type: fence.info.split(/\s+/)[0] ?? '',
+			};
+			continue;
+		}
+
+		if (getFenceCloseInfo(lines[index], {
+			length: open.length,
+			markerCharacter: open.character,
+		})) {
+			open = null;
+		}
+	}
+
+	return open;
+};
+
 const getNornaLineAttempt = (line) => {
 	const match = line.match(/^ {0,3}([`~]{0,2})(norna-[a-z0-9-]+)\s*$/);
 	if (!match) return null;
@@ -226,7 +251,14 @@ const getUnclosedNornaBlockMessage = (opening) =>
 	`This Norna block was started on line ${opening.line} but not closed. Add a closing ${opening.markerCharacter.repeat(opening.length)} line after the last entry.`;
 
 const scanMarkdownFencedBlocks = (markdown, options = {}) => {
-	const lines = normalizeLines(markdown);
+	const normalizedMarkdown = markdown.replace(/\r\n?/g, '\n');
+	const lines = normalizedMarkdown.split('\n');
+	const lineOffsets = [];
+	let nextLineOffset = 0;
+	for (const line of lines) {
+		lineOffsets.push(nextLineOffset);
+		nextLineOffset += line.length + 1;
+	}
 	const lineOffset = options.lineOffset ?? 0;
 	const blocks = [];
 	const errors = [];
@@ -242,6 +274,7 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (attempt) {
 				errors.push({
 					blockType: attempt.type,
+					code: 'invalid-norna-block-start',
 					line: lineNumber,
 					source: '',
 					message: failMessage(getNornaFenceStartMessage(attempt.type, attempt.marker), { ...options, line: lineNumber }),
@@ -257,6 +290,7 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (attempt) {
 				errors.push({
 					blockType: attempt.type,
+					code: 'invalid-norna-block-start',
 					line: lineNumber,
 					source: '',
 					message: failMessage(getNornaFenceStartMessage(attempt.type, attempt.marker), { ...options, line: lineNumber }),
@@ -288,7 +322,10 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (isNornaLike) {
 				errors.push({
 					blockType: type,
+					code: 'unclosed-norna-block',
+					endOffset: normalizedMarkdown.length,
 					line: lineNumber,
+					startOffset: lineOffsets[index],
 					source: lines.slice(bodyStartIndex).join('\n'),
 					message: failMessage(getUnclosedNornaBlockMessage(opening), { ...options, line: lineNumber }),
 				});
@@ -301,13 +338,19 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (nornaBlockTypes.has(type)) {
 				blocks.push({
 					blockType: type,
+					endLine: lineOffset + closingIndex + 1,
+					endOffset: lineOffsets[closingIndex] + lines[closingIndex].length,
 					line: lineNumber,
+					startOffset: lineOffsets[index],
 					source,
+					sourceEndOffset: lineOffsets[closingIndex],
 					sourceLine: lineNumber + 1,
+					sourceStartOffset: lineOffsets[bodyStartIndex],
 				});
 			} else {
 				errors.push({
 					blockType: type,
+					code: 'unknown-norna-block',
 					line: lineNumber,
 					source,
 					message: failMessage(getUnknownNornaBlockMessage(type), { ...options, line: lineNumber }),
@@ -337,7 +380,7 @@ const parseImageListBlock = (source, options = {}) => {
 		const lineNumber = (options.line ?? 1) + index;
 		const itemMatch = line.match(/^(\s*)-\s+image:\s*(.*?)\s*$/);
 		if (itemMatch) {
-			current = { image: decodeScalar(itemMatch[2]) };
+			current = { image: decodeScalar(itemMatch[2]), line: lineNumber };
 			images.push(current);
 			continue;
 		}
@@ -375,7 +418,7 @@ const parseCardListBlock = (source, options = {}) => {
 	let layout = cardListDefinition.options.layout.default;
 	let flow = cardListDefinition.options.flow.default;
 	let size = cardListDefinition.options.size.default;
-	let width = cardListDefinition.options.width.default;
+	let width;
 	let current = null;
 
 	for (const [index, line] of normalizeLines(source).entries()) {
@@ -384,7 +427,7 @@ const parseCardListBlock = (source, options = {}) => {
 		const lineNumber = (options.line ?? 1) + index;
 		const itemMatch = line.match(/^(\s*)-\s+title:\s*(.*?)\s*$/);
 		if (itemMatch) {
-			current = { title: decodeScalar(itemMatch[2]) };
+			current = { title: decodeScalar(itemMatch[2]), line: lineNumber };
 			cards.push(current);
 			continue;
 		}
@@ -452,6 +495,7 @@ const parseCardListBlock = (source, options = {}) => {
 		}
 
 		current[entry.key] = entry.value;
+		if (entry.key === 'link') current.linkLine = lineNumber;
 	}
 
 	for (const card of cards) {
@@ -486,26 +530,6 @@ export const parseNornaMarkdownBlock = (type, source, options = {}) => {
 
 const getLineNumber = (source, index) => source.slice(0, index).split(/\r?\n/).length;
 
-export const extractNornaMarkdownBlocks = (markdown, options = {}) => {
-	const blocks = [];
-	const { blocks: scannedBlocks, errors } = scanMarkdownFencedBlocks(markdown, options);
-
-	if (errors.length > 0) {
-		throw new Error(errors[0].message);
-	}
-
-	for (const block of scannedBlocks) {
-		blocks.push({
-			...parseNornaMarkdownBlock(block.blockType, block.source, { ...options, line: block.sourceLine }),
-			blockType: block.blockType,
-			line: block.line,
-			source: block.source,
-		});
-	}
-
-	return blocks;
-};
-
 export const extractNornaMarkdownBlockDiagnostics = (markdown, options = {}) => {
 	const blocks = [];
 	const { blocks: scannedBlocks, errors } = scanMarkdownFencedBlocks(markdown, options);
@@ -515,12 +539,18 @@ export const extractNornaMarkdownBlockDiagnostics = (markdown, options = {}) =>
 			blocks.push({
 				...parseNornaMarkdownBlock(block.blockType, block.source, { ...options, line: block.sourceLine }),
 				blockType: block.blockType,
+				endLine: block.endLine,
+				endOffset: block.endOffset,
 				line: block.line,
+				startOffset: block.startOffset,
 				source: block.source,
+				sourceEndOffset: block.sourceEndOffset,
+				sourceStartOffset: block.sourceStartOffset,
 			});
 		} catch (error) {
 			errors.push({
 				blockType: block.blockType,
+				code: 'invalid-norna-block',
 				line: block.line,
 				source: block.source,
 				message: error instanceof Error ? error.message : String(error),
@@ -570,18 +600,6 @@ const maskFencedCodeBlocks = (markdown) => {
 const isExternalImageTarget = (target) => /^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith('//');
 const isRootRelativePublicTarget = (target) => target.startsWith('/');
 
-const stripTags = (value) => value.replace(/<[^>]*>/g, '');
-
-const decodeHtmlEntities = (value) =>
-	value
-		.replace(/&amp;/g, '&')
-		.replace(/&lt;/g, '<')
-		.replace(/&gt;/g, '>')
-		.replace(/&quot;/g, '"')
-		.replace(/&#39;/g, "'")
-		.replace(/&#x([0-9a-f]+);/gi, (_match, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
-		.replace(/&#(\d+);/g, (_match, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10)));
-
 export const extractMarkdownImageReferences = (markdown) => {
 	const masked = maskFencedCodeBlocks(markdown);
 	const references = [];
@@ -610,7 +628,7 @@ export const getNornaBlockImageReferences = (blocks) =>
 					alt: card.title,
 					blockType: block.blockType,
 					blockDisplayType: block.type,
-					line: block.line,
+					line: card.line ?? block.line,
 				}));
 		}
 
@@ -618,54 +636,10 @@ export const getNornaBlockImageReferences = (blocks) =>
 			...image,
 			blockType: block.blockType,
 			blockDisplayType: block.type,
-			line: block.line,
+			line: image.line ?? block.line,
 		}));
 	});
 
-export const createNornaMarkdownBlockMarker = (type, source) => {
-	const encodedSource = Buffer.from(source, 'utf8').toString('base64');
-	return `<${markerTagName} data-type="${type}" data-source="${encodedSource}"></${markerTagName}>`;
-};
-
-export const splitNornaMarkdownBlockMarkers = (html, options = {}) => {
-	const blocks = [];
-	const markerRegex = /<norna-block\s+data-type="([^"]+)"\s+data-source="([^"]*)"\s*><\/norna-block>|<pre\b([^>]*)>\s*<code\b([^>]*)>([\s\S]*?)<\/code>\s*<\/pre>/g;
-	let cursor = 0;
-
-	for (const match of html.matchAll(markerRegex)) {
-		const start = match.index ?? 0;
-		if (start > cursor) {
-			blocks.push({ type: 'html', html: html.slice(cursor, start) });
-		}
-
-		if (match[1]) {
-			const blockType = match[1];
-			const source = Buffer.from(match[2] ?? '', 'base64').toString('utf8');
-			blocks.push(parseNornaMarkdownBlock(blockType, source, options));
-		} else {
-			const attributes = `${match[3] ?? ''} ${match[4] ?? ''}`;
-			const blockType = attributes.match(/\blanguage-(norna-[a-z0-9-]+)\b/)?.[1]
-				?? attributes.match(/\bdata-language="(norna-[a-z0-9-]+)"/)?.[1];
-			if (!nornaBlockTypes.has(blockType)) {
-				blocks.push({ type: 'html', html: match[0] });
-			} else {
-				const source = decodeHtmlEntities(stripTags(match[5] ?? ''));
-				blocks.push(parseNornaMarkdownBlock(blockType, source, options));
-			}
-		}
-
-		cursor = start + match[0].length;
-	}
-
-	if (cursor < html.length) {
-		blocks.push({ type: 'html', html: html.slice(cursor) });
-	}
-
-	return blocks.filter((block) => block.type !== 'html' || block.html.trim());
-};
-
-const normalizeBlockSource = (source) => source.replace(/\r\n?/g, '\n').trim();
-
 const inlineNoteReferenceRegex = /\{note-ref\}/g;
 const inlineNoteDeclarationOpeningRegex = /^\s*\{note:\s*(.*)$/;
 const inlineNoteDeclarationClosingRegex = /^(.*?)\}\s*$/;
@@ -918,57 +892,3 @@ export const extractInlineNoteDiagnostics = (markdown, options = {}) => {
 
 	return { notes, errors };
 };
-
-export const splitNornaRenderedCodeBlocks = (html, rawBlocks, options = {}) => {
-	const blocks = [];
-	const renderedCodeRegex = /<pre\b[^>]*>\s*<code\b[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/g;
-	let cursor = 0;
-	let rawIndex = 0;
-
-	for (const match of html.matchAll(renderedCodeRegex)) {
-		const start = match.index ?? 0;
-		if (start > cursor) {
-			blocks.push({ type: 'html', html: html.slice(cursor, start) });
-		}
-
-		const rawBlock = rawBlocks[rawIndex];
-		const renderedSource = normalizeBlockSource(decodeHtmlEntities(stripTags(match[1] ?? '')));
-		const rawSource = normalizeBlockSource(rawBlock?.source ?? '');
-
-		if (rawBlock && renderedSource === rawSource) {
-			blocks.push(parseNornaMarkdownBlock(rawBlock.blockType, rawBlock.source, options));
-			rawIndex += 1;
-		} else {
-			blocks.push({ type: 'html', html: match[0] });
-		}
-
-		cursor = start + match[0].length;
-	}
-
-	if (cursor < html.length) {
-		blocks.push({ type: 'html', html: html.slice(cursor) });
-	}
-
-	return blocks.filter((block) => block.type !== 'html' || block.html.trim());
-};
-
-const visitCodeBlocks = (node) => {
-	if (!node || typeof node !== 'object') return;
-
-	if (Array.isArray(node.children)) {
-		for (const child of node.children) {
-			visitCodeBlocks(child);
-		}
-	}
-
-	if (node.type !== 'code' || !nornaBlockTypes.has(node.lang)) return;
-
-	node.type = 'html';
-	node.value = createNornaMarkdownBlockMarker(node.lang, node.value ?? '');
-	delete node.lang;
-	delete node.meta;
-};
-
-export const nornaMarkdownBlocksRemarkPlugin = () => (tree) => {
-	visitCodeBlocks(tree);
-};

package/scripts/lib/norna-markdown-render-plugin.mjs

@@ -0,0 +1,37 @@
+import { defineMdastPlugin } from 'satteri';
+import { nornaBlockTypes } from './norna-markdown-blocks.mjs';
+
+const stateKey = 'nornaMarkdownRender';
+
+const getState = (context) => {
+	if (!context.data[stateKey]) {
+		context.data[stateKey] = { blockIndex: 0, regionIndex: 0 };
+	}
+	return context.data[stateKey];
+};
+
+export const nornaMarkdownRenderPlugin = defineMdastPlugin({
+	name: 'norna-markdown-render',
+	code(node, context) {
+		if (!nornaBlockTypes.has(node.lang)) return;
+
+		const state = getState(context);
+		const blockIndex = state.blockIndex;
+		state.blockIndex += 1;
+		context.replaceNode(node, {
+			type: 'html',
+			value: `<norna-block data-index="${blockIndex}"></norna-block>`,
+		});
+	},
+	heading(node, context) {
+		if (node.depth !== 1 && node.depth !== 2) return;
+		const state = getState(context);
+		const regionIndex = state.regionIndex;
+		state.blockIndex = 0;
+		state.regionIndex += 1;
+		context.replaceNode(node, {
+			type: 'html',
+			value: `<norna-region data-index="${regionIndex}"></norna-region>`,
+		});
+	},
+});

package/scripts/lib/object.mjs

@@ -0,0 +1,28 @@
+export const isPlainObject = (value) => (
+	value !== null
+	&& typeof value === 'object'
+	&& !Array.isArray(value)
+);
+
+export const freezeDeep = (value) => {
+	if (value === null || typeof value !== 'object' || Object.isFrozen(value)) return value;
+
+	for (const child of Object.values(value)) freezeDeep(child);
+	return Object.freeze(value);
+};
+
+export const mergeDeep = (base, override) => {
+	if (!isPlainObject(override)) return structuredClone(base);
+
+	const merged = structuredClone(base);
+
+	for (const [key, value] of Object.entries(override)) {
+		if (isPlainObject(value) && isPlainObject(merged[key])) {
+			merged[key] = mergeDeep(merged[key], value);
+		} else if (value !== undefined) {
+			merged[key] = value;
+		}
+	}
+
+	return merged;
+};