sommark 2.3.1 → 3.0.0

package/core/plugins/quote-escaper.js

@@ -0,0 +1,37 @@
+/**
+ * Quote Escaper Plugin for SomMark
+ * 
+ * Scope: arguments
+ * 
+ * Automatically escapes special characters within double quotes in arguments.
+ */
+const QuoteEscaper = {
+	name: "quote-escaper",
+	type: "preprocessor",
+	author: "Adam-Elmi",
+	description: "Automatically escapes special characters within double-quoted string arguments.",
+	scope: "arguments",
+	beforeLex(args) {
+		return args.replace(/"([^"]*)"/g, (match, content) => {
+			const options = this.options || {};
+
+			const escapedContent = content
+				.replace(/\\/g, "\\\\")
+				.replace(/\[/g, "\\[")
+				.replace(/\]/g, "\\]")
+				.replace(/=/g, "\\=")
+				.replace(/->/g, "\\->")
+				.replace(/\(/g, "\\(")
+				.replace(/\)/g, "\\)")
+				.replace(/@_/g, "\\@_")
+				.replace(/_@/g, "\\_@")
+				.replace(/:/g, "\\:")
+				.replace(/,/g, "\\,")
+				.replace(/;/g, "\\;")
+				.replace(/#/g, "\\#");
+			return `"${escapedContent}"`;
+		});
+	}
+};
+
+export default QuoteEscaper;

package/core/plugins/raw-content-plugin.js

@@ -0,0 +1,72 @@
+/**
+ * Raw Content Plugin for SomMark
+ * 
+ * Scope: top-level
+ * 
+ * Automatically escapes SomMark tokens within specified blocks to allow raw content.
+ */
+const RawContentPlugin = {
+	name: "raw-content",
+	type: ["preprocessor", "on-ast"],
+	author: "Adam-Elmi",
+	description: "Prevents SomMark syntax parsing within specific blocks (e.g., [code], [mdx]) to allow raw content.",
+	scope: "top-level",
+	options: {
+		targetBlocks: ["mdx", "raw"] // Blocks to treat as raw
+	},
+	beforeLex(src) {
+		let processed = src;
+		const options = this.options || {};
+		const targetBlocks = options.targetBlocks || ["mdx", "raw"];
+
+		targetBlocks.forEach(tag => {
+			const regex = new RegExp(`\\[${tag}([^ \\]]*|\\s*=[^\\]]*)?\\]([\\s\\S]*?)\\[end\\]`, "g");
+			processed = processed.replace(regex, (match, argsPart, content) => {
+				const escapedContent = content
+					.replace(/\\/g, "\\\\")
+					.replace(/\[/g, "\\[")
+					.replace(/\]/g, "\\]")
+					.replace(/@_/g, "\\@_")
+					.replace(/_@/g, "\\_@")
+					.replace(/=/g, "\\=")
+					.replace(/:/g, "\\:")
+					.replace(/,/g, "\\,")
+					.replace(/\(/g, "\\(")
+					.replace(/\)/g, "\\)")
+					.replace(/ /g, "\u200B ")
+					.replace(/\t/g, "\u200B\t")
+					.replace(/\n/g, "\u200B\n")
+					.replace(/\r/g, "\u200B\r");
+				return `[${tag}${argsPart || ""}]${escapedContent}[end]`;
+			});
+		});
+		return processed;
+	},
+
+	onAst(ast) {
+		const options = this.options || {};
+		const targetBlocks = (options.targetBlocks || ["mdx", "raw", "code"]).map(t => t.toLowerCase());
+
+		const processNodes = (nodes) => {
+			if (!Array.isArray(nodes)) return;
+			nodes.forEach(node => {
+				if (node.type === "Block" && targetBlocks.includes(node.id.toLowerCase())) {
+					if (node.body) {
+						node.body.forEach(child => {
+							if (child.type === "Text") {
+								child.text = child.text.replace(/\u200B/g, "");
+							}
+						});
+					}
+				}
+				if (node.body) processNodes(node.body);
+			});
+		};
+
+		const root = Array.isArray(ast) ? ast : [ast];
+		processNodes(root);
+		return ast;
+	}
+};
+
+export default RawContentPlugin;

package/core/plugins/rules-validation-plugin.js

@@ -0,0 +1,197 @@
+import { transpilerError } from "../errors.js";
+
+/**
+ * Rules Validation Plugin
+ * Validates rules defined in mapper files.
+ * Supports rules for arguments (key, value) and content.
+ */
+const RulesValidationPlugin = {
+	name: "rules-validation",
+	type: "on-ast",
+	author: "Adam-Elmi",
+	description: "Validates AST nodes against rules defined in the mapper (e.g., argument count, required keys, content length).",
+	onAst(ast, { mapperFile }) {
+		if (!mapperFile) return ast;
+
+		const validateNode = (node, parentTarget = null) => {
+			if (!node) return;
+
+			// ========================================================================== //
+			//  1. TEXT nodes validation                                                  //
+			// ========================================================================== //
+			if (node.type === "Text" && parentTarget) {
+				this.runValidations(parentTarget, null, node.text, "Text", mapperFile);
+			}
+
+			// ========================================================================== //
+			//  2. Identifier nodes validation (Block, Inline, AtBlock)                   //
+			// ========================================================================== //
+			if (node.id) {
+				const target = mapperFile.get(node.id);
+				if (target) {
+					this.runValidations(target, node.args, this.getContent(node), node.type, mapperFile);
+				}
+			}
+
+			// ========================================================================== //
+			//  Recursive traversal                                                       //
+			// ========================================================================== //
+			if (node.body && Array.isArray(node.body)) {
+				const currentTarget = node.id ? mapperFile.get(node.id) : parentTarget;
+				node.body.forEach(child => validateNode(child, currentTarget));
+			}
+		};
+
+		const root = Array.isArray(ast) ? ast : [ast];
+		root.forEach(node => validateNode(node));
+
+		return ast;
+	},
+
+	getContent(node) {
+		if (node.type === "Inline") return node.value;
+		if (node.type === "AtBlock") return node.content;
+		return "";
+	},
+
+	runValidations(target, args, content, type, mapperFile) {
+		if (!target.options) return;
+		const rules = target.options.rules || {};
+		const id = Array.isArray(target.id) ? target.id.join(" | ") : target.id;
+
+		// ========================================================================== //
+		//  1. Validate Args Count & Keys                                             //
+		// ========================================================================== //
+		if (args && rules.args) {
+			const { min, max, required, includes } = rules.args;
+			const argKeys = Object.keys(args).filter(key => isNaN(parseInt(key)));
+			const argCount = args.length;
+
+			if (min !== undefined && argCount < min) {
+				transpilerError([
+					"{line}<$red:Validation Error:$> ",
+					`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:requires at least$> <$green:${min}$> <$yellow:argument(s). Found$> <$red:${argCount}$>{line}`
+				]);
+			}
+			if (max !== undefined && argCount > max) {
+				transpilerError([
+					"{line}<$red:Validation Error:$> ",
+					`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:accepts at most$> <$green:${max}$> <$yellow:argument(s). Found$> <$red:${argCount}$>{line}`
+				]);
+			}
+			if (required && Array.isArray(required)) {
+				const missingKeys = required.filter(key => !Object.prototype.hasOwnProperty.call(args, key));
+				if (missingKeys.length > 0) {
+					transpilerError([
+						"{line}<$red:Validation Error:$> ",
+						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:is missing required argument(s):$> <$red:${missingKeys.join(", ")}$>{line}`
+					]);
+				}
+			}
+			if (includes && Array.isArray(includes)) {
+				const invalidKeys = argKeys.filter(key => {
+					return !includes.includes(key) && !mapperFile.extraProps.has(key);
+				});
+				if (invalidKeys.length > 0) {
+					transpilerError([
+						"{line}<$red:Validation Error:$> ",
+						`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:contains invalid argument key(s):$> <$red:${invalidKeys.join(", ")}$>`,
+						`{N}<$yellow:Allowed keys are:$> <$green:${includes.join(", ")}$>{line}`
+					]);
+				}
+			}
+		}
+
+		// ========================================================================== //
+		//  2. Validation on Keys and Values                                          //
+		// ========================================================================== //
+		if (args) {
+			const argKeys = Object.keys(args).filter(key => isNaN(parseInt(key)));
+			
+			// Validate keys pattern
+			if (rules.keys) {
+				const keyPattern = rules.keys instanceof RegExp ? rules.keys : null;
+				if (keyPattern) {
+					const invalidKeys = argKeys.filter(key => !keyPattern.test(key));
+					if (invalidKeys.length > 0) {
+						transpilerError([
+							"{line}<$red:Validation Error:$> ",
+							`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:contains argument keys that do not match pattern $> <$green:${keyPattern.toString()}$>: <$red:${invalidKeys.join(", ")}$>{line}`
+						]);
+					}
+				}
+			}
+
+			// ========================================================================== //
+			//  Validate specific values                                                  //
+			// ========================================================================== //
+			if (rules.values) {
+				for (const [key, value] of Object.entries(args)) {
+					if (isNaN(parseInt(key))) {
+						const valueRule = rules.values[key];
+						if (valueRule) {
+							if (valueRule instanceof RegExp && !valueRule.test(value)) {
+								transpilerError([
+									"{line}<$red:Validation Error:$> ",
+									`<$yellow:Argument key$> <$blue:'${key}'$> <$yellow:in$> <$blue:'${id}'$> <$yellow:has invalid value:$> <$red:'${value}'$>{N}<$yellow:Expected to match pattern:$> <$green:${valueRule.toString()}$>{line}`
+								]);
+							} else if (typeof valueRule === "function" && !valueRule(value)) {
+								transpilerError([
+									"{line}<$red:Validation Error:$> ",
+									`<$yellow:Argument key$> <$blue:'${key}'$> <$yellow:in$> <$blue:'${id}'$> <$yellow:failed custom validation for value:$> <$red:'${value}'$>{line}`
+								]);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// ========================================================================== //
+		//  3. Content Validation                                                     //
+		// ========================================================================== //
+		if (content !== undefined && rules.content) {
+			const { maxLength, match } = rules.content;
+			if (maxLength && content.length > maxLength) {
+				transpilerError([
+					"{line}<$red:Validation Error:$> ",
+					`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:content exceeds maximum length of$> <$green:${maxLength}$> <$yellow:characters. Found$> <$red:${content.length}$>{line}`
+				]);
+			}
+			if (match && match instanceof RegExp && !match.test(content)) {
+				transpilerError([
+					"{line}<$red:Validation Error:$> ",
+					`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:content does not match required pattern:$> <$green:${match.toString()}$>{line}`
+				]);
+			}
+		}
+
+		// ========================================================================== //
+		//  4. self-closing                                                           //
+		// ========================================================================== //
+		if (rules.is_self_closing && (type === "Block" || content)) {
+			if (content) {
+				transpilerError([
+					"{line}<$red:Validation Error:$> ",
+					`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:is self-closing tag and is not allowed to have a content | children$>{line}`
+				]);
+			}
+		}
+
+		// ========================================================================== //
+		//  5. Type Validation (Block, Inline, AtBlock)                               //
+		// ========================================================================== //
+		const typeToValidate = target.options.type;
+		if (typeToValidate && type !== "Text") {
+			const allowedTypes = Array.isArray(typeToValidate) ? typeToValidate : [typeToValidate];
+			if (!allowedTypes.includes("any") && !allowedTypes.includes(type)) {
+				transpilerError([
+					"{line}<$red:Validation Error:$> ",
+					`<$yellow:Identifier$> <$blue:'${id}'$> <$yellow:is expected to be type$> <$green:'${allowedTypes.join(" | ")}'$>{N}<$cyan:Received type: $> <$magenta:'${type}'$>{line}`
+				]);
+			}
+		}
+	}
+};
+
+export default RulesValidationPlugin;

package/core/plugins/sommark-format.js

@@ -0,0 +1,211 @@
+export default {
+	name: "sommark-format",
+	type: "on-ast",
+	author: "Adam-Elmi",
+	description: "Formats SomMark AST into a standardized formatted string.",
+	options: {
+		indentString: "\t"
+	},
+	onAst(ast) {
+		const indentStr = this.options?.indentString || "\t";
+		
+		const escapeArg = (val, type) => {
+			let escaped = String(val)
+				.replace(/\\/g, "\\\\")
+				.replace(/,/g, "\\,");
+			
+			if (type === "Block" || type === "AtBlock") {
+				escaped = escaped.replace(/:/g, "\\:");
+			}
+			if (type === "AtBlock") {
+				escaped = escaped.replace(/;/g, "\\;");
+			}
+			if (type === "Block" && escaped.startsWith("=")) {
+				escaped = escaped.replace(/^=/, "\\=");
+			}
+			return escaped;
+		};
+
+		const escapeInlineValue = (val) => {
+			return String(val)
+				.replace(/\\/g, "\\\\")
+				.replace(/\)/g, "\\)");
+		};
+
+		const escapeText = (str) => {
+			return String(str)
+				.replace(/\\/g, "\\\\")
+				.replace(/\[/g, "\\[")
+				.replace(/\]/g, "\\]")
+				.replace(/\(/g, "\\(")
+				.replace(/\)/g, "\\)")
+				.replace(/->/g, "\\->")
+				.replace(/@_/g, "\\@_")
+				.replace(/_@/g, "\\_@")
+				.replace(/#/g, "\\#");
+		};
+
+		const formatArgs = (args, type) => {
+			if (!args || args.length === 0) return "";
+			let usedKeys = new Set();
+			let formattedArgs = [];
+			
+			for (let i = 0; i < args.length; i++) {
+				let val = args[i];
+				let matchedKey = null;
+				if (type !== "Inline") {
+					for (let key of Object.keys(args)) {
+						if (isNaN(parseInt(key)) && args[key] === val && !usedKeys.has(key)) {
+							matchedKey = key;
+							usedKeys.add(key);
+							break;
+						}
+					}
+				}
+				
+				let escapedVal = escapeArg(val, type);
+				if (matchedKey) {
+					formattedArgs.push(`${matchedKey}:${escapedVal}`);
+				} else {
+					formattedArgs.push(escapedVal);
+				}
+			}
+			
+			let res = formattedArgs.join(", ");
+			if (!res) return "";
+			
+			if (type === "Block") return " = " + res;
+			if (type === "AtBlock") return ": " + res + ";";
+			if (type === "Inline") return ": " + res;
+			
+			return res;
+		};
+
+		const formatBody = (body, depth) => {
+			if (!body || !Array.isArray(body)) return "";
+			const innerIndentStr = depth >= 0 ? indentStr.repeat(depth) : "";
+			let result = "";
+			let currentText = "";
+
+			const flushText = () => {
+				if (!currentText) return;
+				let cleanText = currentText
+					.replace(/[ \t]+/g, " ")             // collapse horizontal spaces
+					.replace(/\n([ \t]*\n)+/g, "\n\n")   // preserve max 1 empty line (paragraphs)
+					.trim();
+				
+				if (cleanText) {
+					const indentedText = cleanText.split('\n').map(line => {
+						return line.trim() ? innerIndentStr + line.trim() : "";
+					}).join('\n');
+					result += `${indentedText}\n`;
+				}
+				currentText = "";
+			};
+
+			for (let i = 0; i < body.length; i++) {
+				const child = body[i];
+				if (child.type === "Text") {
+					let textStr = escapeText(child.text);
+					
+					// Separate Text from a preceding Inline statement
+					if (i > 0 && body[i - 1].type === "Inline") {
+						// Don't add space if the text starts with punctuation or already starts with whitespace
+						if (textStr.length > 0 && !/^\s/.test(textStr) && !/^[.,!?;:\])}>"']/.test(textStr)) {
+							textStr = " " + textStr;
+						}
+					}
+					currentText += textStr;
+				} else if (child.type === "Inline") {
+					const argsStr = formatArgs(child.args, "Inline");
+					const inlineVal = child.value ? String(child.value).trim() : "";
+					const inlineStr = `(${escapeInlineValue(inlineVal)})->(${child.id}${argsStr})`;
+					
+					if (i > 0) {
+						const prev = body[i - 1];
+						if (prev.type === "Inline") {
+							if (!/[ \t\n\r]$/.test(currentText)) currentText += " ";
+						} else if (prev.type === "Text") {
+							if (currentText.length > 0 && !/[ \t\n\r]$/.test(currentText)) {
+								// Don't add space if text ends with opening punctuation/quotes
+								if (!/[({\[<"']$/.test(currentText)) currentText += " ";
+							}
+						}
+					}
+					currentText += inlineStr;
+				} else {
+				// Helper: check if a block has no meaningful body content
+				const isEmptyBlock = (node) => {
+					if (node.type !== "Block") return false;
+					if (!node.body || node.body.length === 0) return true;
+					// Body with only whitespace text nodes
+					return node.body.every(
+						n => n.type === "Text" && !n.text.trim()
+					);
+				};
+
+				if (child.type === "Block" && isEmptyBlock(child)) {
+					// Keep empty blocks inline with surrounding text
+					const argsStr = formatArgs(child.args, "Block");
+					const blockStr = `[${child.id}${argsStr}][end]`;
+					
+					if (i > 0) {
+						const prev = body[i - 1];
+						if (prev.type === "Text" || prev.type === "Inline") {
+							if (currentText.length > 0 && !/[ \t\n\r]$/.test(currentText)) {
+								if (!/[({\[<"']$/.test(currentText)) currentText += " ";
+							}
+						}
+					}
+					currentText += blockStr;
+				} else {
+					flushText();
+					if (child.type === "Block") {
+						const argsStr = formatArgs(child.args, "Block");
+						result += `${innerIndentStr}[${child.id}${argsStr}]\n`;
+						result += formatBody(child.body, depth + 1);
+						result += `${innerIndentStr}[end]\n`;
+					} else if (child.type === "AtBlock") {
+						const argsStr = formatArgs(child.args, "AtBlock");
+						result += `${innerIndentStr}@_${child.id}_@${argsStr}\n`;
+						if (child.content) {
+							// Remove the leading spaces from the messy text block then re-indent properly
+							const lines = child.content.replace(/\r\n/g, '\n').split('\n');
+							while (lines.length && !lines[0].trim()) lines.shift();
+							while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+							
+							let minIndent = Infinity;
+							for (const line of lines) {
+								if (line.trim()) {
+									const leadingSpaces = line.match(/^[ \t]*/)[0].length;
+									if (leadingSpaces < minIndent) minIndent = leadingSpaces;
+								}
+							}
+							if (minIndent === Infinity) minIndent = 0;
+							
+							const indentedContent = lines.map(line => {
+								if (!line.trim()) return "";
+								return innerIndentStr + indentStr + line.substring(minIndent);
+							}).join('\n');
+							
+							result += indentedContent + "\n";
+						}
+						result += `${innerIndentStr}@_end_@\n`;
+					} else if (child.type === "Comment") {
+						result += `${innerIndentStr}# ${child.text.replace(/^#+\s*/, "").trim()}\n`;
+					}
+				}
+			}
+			}
+			flushText();
+			return result;
+		};
+		
+		const rootNodes = Array.isArray(ast) ? ast : [ast];
+		
+		// The formatted string is available via `plugin.formattedSource`
+		this.formattedSource = formatBody(rootNodes, 0).trim() + "\n";
+		
+		return ast; // Return original AST
+	}
+};