@refrakt-md/editor 0.8.0 → 0.8.2

package/app/src/lib/editor/block-parser.ts

@@ -1,4 +1,5 @@
 import type { RuneInfo } from '../api/client.js';
+import type { ResolvedStructure, ResolvedField } from './content-model-resolver.js';
 
 /**
  * Block types recognized by the visual editor.
@@ -149,8 +150,11 @@ export function parseBlocks(source: string): ParsedBlock[] {
 
 		// ── Fenced code blocks ───────────────────────────────────
 		if (trimmed.startsWith('```') || trimmed.startsWith('~~~')) {
-			const fence = trimmed.slice(0, 3);
-			const lang = trimmed.slice(3).trim();
+			const fenceChar = trimmed[0];
+			let fenceLen = 3;
+			while (fenceLen < trimmed.length && trimmed[fenceLen] === fenceChar) fenceLen++;
+			const fence = trimmed.slice(0, fenceLen);
+			const lang = trimmed.slice(fenceLen).trim();
 			const start = i;
 			i++;
 			const codeLines: string[] = [];
@@ -395,8 +399,11 @@ export function parseContentTree(content: string): ContentNode[] {
 
 		// Fenced code
 		if (trimmed.startsWith('```') || trimmed.startsWith('~~~')) {
-			const fence = trimmed.slice(0, 3);
-			const lang = trimmed.slice(3).trim();
+			const fenceChar = trimmed[0];
+			let fenceLen = 3;
+			while (fenceLen < trimmed.length && trimmed[fenceLen] === fenceChar) fenceLen++;
+			const fence = trimmed.slice(0, fenceLen);
+			const lang = trimmed.slice(fenceLen).trim();
 			const start = i;
 			i++;
 			const codeStart = i;
@@ -504,13 +511,26 @@ export function parseContentTree(content: string): ContentNode[] {
 		// List
 		if (/^(\d+\.|[-*+])\s/.test(trimmed)) {
 			const start = i;
+			const ordered = /^\d+\./.test(trimmed);
 			while (i < lines.length) {
 				const lt = lines[i].trimStart();
-				if (/^(\d+\.|[-*+])\s/.test(lt) || (lt === '' && i + 1 < lines.length && /^(\s+|\d+\.|[-*+]\s)/.test(lines[i + 1])) || (lt !== '' && lines[i].startsWith('  '))) {
+				if (/^(\d+\.|[-*+])\s/.test(lt)) {
+					// Stop if the list marker type switches (e.g. unordered → ordered)
+					const nextOrdered = /^\d+\./.test(lt);
+					if (nextOrdered !== ordered && i > start) break;
+					i++;
+				} else if (lt === '' && i + 1 < lines.length && /^(\s+|\d+\.|[-*+]\s)/.test(lines[i + 1])) {
+					// Blank line followed by continuation — but stop if the next item switches type
+					const nextNonBlank = lines[i + 1].trimStart();
+					if (/^(\d+\.|[-*+])\s/.test(nextNonBlank)) {
+						const nextOrdered = /^\d+\./.test(nextNonBlank);
+						if (nextOrdered !== ordered) break;
+					}
+					i++;
+				} else if (lt !== '' && lines[i].startsWith('  ')) {
 					i++;
 				} else { break; }
 			}
-			const ordered = /^\d+\./.test(trimmed);
 			nodes.push({ type: 'list', label: ordered ? 'Ordered list' : 'List', source: lines.slice(start, i).join('\n'), listOrdered: ordered });
 			continue;
 		}
@@ -538,6 +558,404 @@ export function replaceNodeSource(parentContent: string, oldSource: string, newS
 	return parentContent.slice(0, idx) + newSource + parentContent.slice(idx + oldSource.length);
 }
 
+// ── Content model field insertion / removal ──────────────────────────
+
+/** Default markdown template for a field's match type */
+function defaultTemplate(match: string): string {
+	const primary = match.includes('|') ? match.split('|')[0] : match;
+	switch (primary) {
+		case 'heading': return '## Heading';
+		case 'heading:1': return '# Heading';
+		case 'heading:2': return '## Heading';
+		case 'heading:3': return '### Heading';
+		case 'heading:4': return '#### Heading';
+		case 'heading:5': return '##### Heading';
+		case 'heading:6': return '###### Heading';
+		case 'paragraph': return 'Text content';
+		case 'list': case 'list:unordered': return '- Item 1\n- Item 2';
+		case 'list:ordered': return '1. Item 1\n2. Item 2';
+		case 'fence': return '```\ncode\n```';
+		case 'image': return '![alt](url)';
+		case 'blockquote': case 'quote': return '> Quote';
+		case 'any': return 'Content';
+		default: return 'Content';
+	}
+}
+
+/**
+ * Insert content for an empty field in a resolved structure.
+ * Returns the updated innerContent string.
+ */
+export function insertFieldContent(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	zoneName?: string,
+): string {
+	const { field, fields } = findField(structure, fieldName, zoneName);
+	if (!field || field.filled) return innerContent;
+
+	const template = field.template || defaultTemplate(field.match);
+
+	if (structure.type === 'delimited' && zoneName) {
+		return insertInDelimited(innerContent, structure, zoneName, fieldName, fields!, template);
+	}
+
+	if (structure.type === 'sequence') {
+		return insertInSequence(innerContent, structure.fields, fieldName, template);
+	}
+
+	return innerContent;
+}
+
+/**
+ * Remove content for a filled field in a resolved structure.
+ * Returns the updated innerContent string.
+ */
+export function removeFieldContent(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	zoneName?: string,
+): string {
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+
+	let result = innerContent;
+	// Remove all matched nodes' source text (reverse order to preserve indices)
+	for (let i = field.nodes.length - 1; i >= 0; i--) {
+		const nodeSource = field.nodes[i].source;
+		result = removeNodeSource(result, nodeSource);
+	}
+
+	// Clean up double blank lines left by removal
+	result = result.replace(/\n{3,}/g, '\n\n');
+
+	return result;
+}
+
+/**
+ * Append a new item to a filled list field.
+ * Returns the updated innerContent string.
+ */
+export function appendListItem(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	zoneName?: string,
+): string {
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+
+	const template = field.template || '- New item';
+	const lastNode = field.nodes[field.nodes.length - 1];
+	const idx = innerContent.indexOf(lastNode.source);
+	if (idx === -1) return innerContent;
+
+	// For ordered lists, adjust the number to follow the last item
+	let finalTemplate = template;
+	if (field.match === 'list:ordered') {
+		const numMatch = lastNode.source.match(/^(\d+)\./);
+		const nextNum = numMatch ? parseInt(numMatch[1], 10) + 1 : field.nodes.length + 1;
+		finalTemplate = template.replace(/^\d+\./, `${nextNum}.`);
+	}
+
+	const afterEnd = idx + lastNode.source.length;
+	return innerContent.slice(0, afterEnd) + '\n' + finalTemplate + innerContent.slice(afterEnd);
+}
+
+/**
+ * Remove a single item from a list field by index.
+ * If the last item is removed, removes the entire list node.
+ */
+export function removeListItem(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	itemIndex: number,
+	zoneName?: string,
+): string {
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+
+	// Get the list source from the first list node
+	const listNode = field.nodes[0];
+	const items = splitListItems(listNode.source);
+	if (itemIndex < 0 || itemIndex >= items.length) return innerContent;
+
+	if (items.length === 1) {
+		// Removing the last item — remove the entire list node
+		return removeNodeSource(innerContent, listNode.source);
+	}
+
+	// Remove the item and rejoin
+	const remaining = items.filter((_, i) => i !== itemIndex);
+	const newListSource = remaining.join('\n\n');
+	const idx = innerContent.indexOf(listNode.source);
+	if (idx === -1) return innerContent;
+	return innerContent.slice(0, idx) + newListSource + innerContent.slice(idx + listNode.source.length);
+}
+
+/**
+ * Reorder a list item within a list field by moving it from one index to another.
+ * For ordered lists, renumbers the items after reordering.
+ */
+export function reorderListItem(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	fromIndex: number,
+	toIndex: number,
+	zoneName?: string,
+): string {
+	if (fromIndex === toIndex) return innerContent;
+
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+
+	const listNode = field.nodes[0];
+	const items = splitListItems(listNode.source);
+	if (fromIndex < 0 || fromIndex >= items.length || toIndex < 0 || toIndex >= items.length) return innerContent;
+
+	// Move item from fromIndex to toIndex
+	const reordered = [...items];
+	const [moved] = reordered.splice(fromIndex, 1);
+	reordered.splice(toIndex, 0, moved);
+
+	// For ordered lists, renumber items
+	const isOrdered = field.match === 'list:ordered' || /^\d+\.\s/.test(items[0]);
+	if (isOrdered) {
+		for (let i = 0; i < reordered.length; i++) {
+			reordered[i] = reordered[i].replace(/^\d+\./, `${i + 1}.`);
+		}
+	}
+
+	const newListSource = reordered.join('\n');
+	const idx = innerContent.indexOf(listNode.source);
+	if (idx === -1) return innerContent;
+	return innerContent.slice(0, idx) + newListSource + innerContent.slice(idx + listNode.source.length);
+}
+
+/**
+ * Append a new item to a filled greedy field.
+ * Inserts a default template after the last node in field.nodes[].
+ */
+export function appendGreedyItem(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	zoneName?: string,
+): string {
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+
+	const template = field.template || defaultTemplate(field.match);
+	const lastNode = field.nodes[field.nodes.length - 1];
+	const idx = innerContent.indexOf(lastNode.source);
+	if (idx === -1) return innerContent;
+
+	const afterEnd = idx + lastNode.source.length;
+	return innerContent.slice(0, afterEnd) + '\n\n' + template + innerContent.slice(afterEnd);
+}
+
+/**
+ * Remove a single node from a greedy field by index.
+ */
+export function removeGreedyItem(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	itemIndex: number,
+	zoneName?: string,
+): string {
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+	if (itemIndex < 0 || itemIndex >= field.nodes.length) return innerContent;
+
+	const nodeSource = field.nodes[itemIndex].source;
+	let result = removeNodeSource(innerContent, nodeSource);
+	result = result.replace(/\n{3,}/g, '\n\n');
+	return result;
+}
+
+/**
+ * Reorder a node within a greedy field by moving it from one index to another.
+ */
+export function reorderGreedyItem(
+	innerContent: string,
+	structure: ResolvedStructure,
+	fieldName: string,
+	fromIndex: number,
+	toIndex: number,
+	zoneName?: string,
+): string {
+	if (fromIndex === toIndex) return innerContent;
+
+	const { field } = findField(structure, fieldName, zoneName);
+	if (!field || !field.filled || field.nodes.length === 0) return innerContent;
+	if (fromIndex < 0 || fromIndex >= field.nodes.length) return innerContent;
+	if (toIndex < 0 || toIndex >= field.nodes.length) return innerContent;
+
+	const nodesSources = field.nodes.map(n => n.source);
+
+	const reordered = [...nodesSources];
+	const [moved] = reordered.splice(fromIndex, 1);
+	reordered.splice(toIndex, 0, moved);
+
+	// Find the span from the first node to the last node in innerContent
+	const firstSource = field.nodes[0].source;
+	const lastSource = field.nodes[field.nodes.length - 1].source;
+	const spanStart = innerContent.indexOf(firstSource);
+	const lastIdx = innerContent.indexOf(lastSource);
+	if (spanStart === -1 || lastIdx === -1) return innerContent;
+	const spanEnd = lastIdx + lastSource.length;
+
+	const newSpan = reordered.join('\n\n');
+	return innerContent.slice(0, spanStart) + newSpan + innerContent.slice(spanEnd);
+}
+
+/**
+ * Split a list source into individual item sources.
+ * Each item starts with a list marker (-, *, +, or 1.) and may have
+ * indented continuation lines or blank-line separated paragraphs.
+ */
+export function splitListItems(listSource: string): string[] {
+	const lines = listSource.split('\n');
+	const items: string[] = [];
+	let current: string[] = [];
+
+	for (const line of lines) {
+		if (/^[-*+]\s|^\d+\.\s/.test(line) && current.length > 0) {
+			items.push(current.join('\n'));
+			current = [line];
+		} else {
+			current.push(line);
+		}
+	}
+	if (current.length > 0) items.push(current.join('\n'));
+	return items;
+}
+
+function findField(
+	structure: ResolvedStructure,
+	fieldName: string,
+	zoneName?: string,
+): { field: ResolvedField | null; fields: ResolvedField[] | null } {
+	if (structure.type === 'sequence') {
+		const field = structure.fields.find(f => f.name === fieldName) ?? null;
+		return { field, fields: structure.fields };
+	}
+	if (structure.type === 'delimited' && zoneName) {
+		const zone = structure.zones.find(z => z.name === zoneName);
+		if (!zone) return { field: null, fields: null };
+		const field = zone.fields.find(f => f.name === fieldName) ?? null;
+		return { field, fields: zone.fields };
+	}
+	return { field: null, fields: null };
+}
+
+/** Remove a node's source from content, handling surrounding whitespace */
+function removeNodeSource(content: string, nodeSource: string): string {
+	const idx = content.indexOf(nodeSource);
+	if (idx === -1) return content;
+
+	let start = idx;
+	let end = idx + nodeSource.length;
+
+	// Extend to consume surrounding blank lines
+	while (start > 0 && content[start - 1] === '\n') start--;
+	if (start > 0) start++; // Keep one newline
+	while (end < content.length && content[end] === '\n') end++;
+
+	return content.slice(0, start) + content.slice(end);
+}
+
+function insertInSequence(
+	innerContent: string,
+	fields: ResolvedField[],
+	fieldName: string,
+	template: string,
+): string {
+	const fieldIndex = fields.findIndex(f => f.name === fieldName);
+	if (fieldIndex === -1) return innerContent;
+
+	// Find the last filled field before this one to insert after
+	let insertAfterNode: ContentNode | null = null;
+	for (let i = fieldIndex - 1; i >= 0; i--) {
+		if (fields[i].filled && fields[i].nodes.length > 0) {
+			const nodes = fields[i].nodes;
+			insertAfterNode = nodes[nodes.length - 1];
+			break;
+		}
+	}
+
+	if (insertAfterNode) {
+		const idx = innerContent.indexOf(insertAfterNode.source);
+		if (idx !== -1) {
+			const afterEnd = idx + insertAfterNode.source.length;
+			return innerContent.slice(0, afterEnd) + '\n\n' + template + innerContent.slice(afterEnd);
+		}
+	}
+
+	// Find the first filled field after this one to insert before
+	for (let i = fieldIndex + 1; i < fields.length; i++) {
+		if (fields[i].filled && fields[i].nodes.length > 0) {
+			const beforeNode = fields[i].nodes[0];
+			const idx = innerContent.indexOf(beforeNode.source);
+			if (idx !== -1) {
+				return innerContent.slice(0, idx) + template + '\n\n' + innerContent.slice(idx);
+			}
+		}
+	}
+
+	// No adjacent filled fields — append to content
+	const trimmed = innerContent.trimEnd();
+	return trimmed + (trimmed ? '\n\n' : '') + template;
+}
+
+function insertInDelimited(
+	innerContent: string,
+	structure: ResolvedStructure & { type: 'delimited' },
+	zoneName: string,
+	fieldName: string,
+	fields: ResolvedField[],
+	template: string,
+): string {
+	const zoneIndex = structure.zones.findIndex(z => z.name === zoneName);
+	if (zoneIndex === -1) return innerContent;
+
+	// Split content at delimiters (---) to find zone boundaries
+	const lines = innerContent.split('\n');
+	const delimiterIndices: number[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (lines[i].trim() === '---') delimiterIndices.push(i);
+	}
+
+	// If the target zone doesn't exist yet (no delimiter), add one
+	if (zoneIndex > 0 && delimiterIndices.length < zoneIndex) {
+		const trimmed = innerContent.trimEnd();
+		const missingDelimiters = zoneIndex - delimiterIndices.length;
+		let insert = '';
+		for (let i = 0; i < missingDelimiters; i++) {
+			insert += '\n\n---';
+		}
+		return trimmed + insert + '\n\n' + template;
+	}
+
+	// Zone exists — insert within it using sequence logic
+	// Determine the zone's content range in lines
+	const zoneStart = zoneIndex === 0 ? 0 : delimiterIndices[zoneIndex - 1] + 1;
+	const zoneEnd = zoneIndex < delimiterIndices.length ? delimiterIndices[zoneIndex] : lines.length;
+	const zoneContent = lines.slice(zoneStart, zoneEnd).join('\n');
+
+	const updatedZone = insertInSequence(zoneContent, fields, fieldName, template);
+
+	const before = lines.slice(0, zoneStart).join('\n');
+	const after = lines.slice(zoneEnd).join('\n');
+
+	return [before, updatedZone, after].filter(Boolean).join('\n');
+}
+
 // ── Serialization ────────────────────────────────────────────────────
 
 /** Reconstruct source text from blocks */

package/dist/server.d.ts

@@ -40,6 +40,7 @@ export interface EditorOptions {
             values?: string[];
         }>;
         example?: string;
+        contentModel?: object;
     }>;
 }
 export declare function startEditor(options: EditorOptions): Promise<void>;

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAShF,MAAM,WAAW,aAAa;IAC7B,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,iDAAiD;IACjD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,kBAAkB,EAAE,MAAM,CAAC,CAAC;IAC9D,qDAAqD;IACrD,cAAc,CAAC,EAAE,KAAK,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QACrD,WAAW,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QACvC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,OAAO,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;QACnF,OAAO,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACH;AAgCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAsTvE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAShF,MAAM,WAAW,aAAa;IAC7B,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,iDAAiD;IACjD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,kBAAkB,EAAE,MAAM,CAAC,CAAC;IAC9D,qDAAqD;IACrD,cAAc,CAAC,EAAE,KAAK,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QACrD,WAAW,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QACvC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,OAAO,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;QACnF,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,YAAY,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;CACH;AAkCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAoUvE"}