sommark 4.0.3 → 4.2.0

package/mappers/languages/json.js

@@ -9,7 +9,7 @@ import { getPositionalArgs, matchedValue, safeArg } from "../../helpers/utils.js
 /**
  * Returns a string representing the specified indentation level.
  */
-function getIndent(depth) {
+export function getIndent(depth) {
 	return "  ".repeat(depth);
 }
 
@@ -18,21 +18,35 @@ function getIndent(depth) {
  * @param {string} str - The string to escape.
  * @param {boolean} [trim=false] - Whether to trim the string.
  */
-function escapeString(str, trim = false) {
+export function escapeString(str, trim = false) {
 	let out = String(str);
 	if (trim) out = out.trim();
 	return JSON.stringify(out);
 }
 
+import evaluator from "../../core/evaluator.js";
+
 /**
  * Recursively extracts text content from a node, ignoring structural metadata.
+ * Evaluates StaticLogic nodes using the Evaluator to inject build-time values.
  */
-function getNodeText(node) {
+async function getNodeText(node) {
 	if (!node.body) return "";
 	let text = "";
 	for (const child of node.body) {
-		if (child.type === "Text") text += child.text;
-		else if (child.type === "Block") text += getNodeText(child);
+		if (child.type === "Text") text += child.text || "";
+		else if (child.type === "StaticLogic") {
+			try {
+				const result = await evaluator.execute(child.code);
+				if (result !== undefined && typeof result !== "object") {
+					text += String(result);
+				}
+			} catch (err) {
+				console.error(`\x1b[31mLogic Error in JSON mapper:\x1b[0m ${err.message}`);
+				console.error(`\x1b[33mCode:\x1b[0m \x1b[34m${child.code}\x1b[0m`);
+			}
+		}
+		else if (child.type === "Block") text += await getNodeText(child);
 	}
 	return text;
 }
@@ -40,7 +54,9 @@ function getNodeText(node) {
 /**
  * Resolves the key-value pairing for a JSON member.
  */
-function renderMember(args, value) {
+export function renderMember(args, value, inArray = false) {
+	if (inArray) return value;
+
 	const posArgs = getPositionalArgs(args);
 	const key = args.key || posArgs[0]; // The 'key' rule determines the member name
 
@@ -53,37 +69,63 @@ function renderMember(args, value) {
 /**
  * Formats a given node and tracks its indentation.
  */
-async function renderNode(node, mapper, depth = 0) {
+export async function renderNode(node, mapper, depth = 0, inArray = false) {
 	const target = matchedValue(mapper.outputs, node.id) || mapper.getUnknownTag(node);
 	if (!target) return "";
 
-	const textContent = getNodeText(node);
-	return await target.render.call(mapper, {
+	evaluator.pushScope();
+	const textContent = await getNodeText(node);
+	const output = await target.render.call(mapper, {
 		nodeType: node.type,
 		args: node.args,
 		content: "",
 		textContent,
 		ast: node,
-		depth
+		depth,
+		inArray
 	});
+	await evaluator.popScope();
+	return output;
 }
 
 /**
  * Formats the children of a node into a neat list.
  */
-async function renderChildren(node, mapper, depth = 0) {
+export async function renderChildren(node, mapper, depth = 0, inArray = false) {
 	let results = [];
 	const childIndent = getIndent(depth + 1);
 
 	for (const child of node.body) {
 		if (child.type === "Block") {
-			const output = await renderNode(child, mapper, depth + 1);
+			const output = await renderNode(child, mapper, depth + 1, inArray);
 			if (output) {
-				results.push(childIndent + output);
+				results.push({ type: "Block", value: childIndent + output });
+			}
+		}
+	}
+
+	let finalOutput = "";
+	for (let i = 0; i < results.length; i++) {
+		const current = results[i];
+		finalOutput += current.value;
+
+		if (current.type === "Block") {
+			// Add comma if there is another Block later
+			let hasNextBlock = false;
+			for (let j = i + 1; j < results.length; j++) {
+				if (results[j].type === "Block") {
+					hasNextBlock = true;
+					break;
+				}
 			}
+			if (hasNextBlock) finalOutput += ",";
+		}
+
+		if (i < results.length - 1) {
+			finalOutput += "\n";
 		}
 	}
-	return results.join(",\n");
+	return finalOutput;
 }
 
 const Json = Mapper.define({});
@@ -91,52 +133,53 @@ const Json = Mapper.define({});
 /**
  * The JSON object node rule.
  */
-Json.register(["Object", "object"], async ({ args, ast, depth = 0 }) => {
-	if (ast.body.length === 0) return renderMember(args, "{}");
-	const content = await renderChildren(ast, Json, depth);
+Json.register(["Object", "object"], async ({ args, ast, depth = 0, inArray = false }) => {
+	if (ast.body.length === 0) return renderMember(args, "{}", inArray);
+	const content = await renderChildren(ast, Json, depth, false);
 	const val = `{\n${content}\n${getIndent(depth)}}`;
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
 /**
  * The JSON array node rule.
  */
-Json.register(["Array", "array"], async ({ args, ast, depth = 0 }) => {
-	if (ast.body.length === 0) return renderMember(args, "[]");
-	const content = await renderChildren(ast, Json, depth);
+Json.register(["Array", "array"], async ({ args, ast, depth = 0, inArray = false }) => {
+	if (ast.body.length === 0) return renderMember(args, "[]", inArray);
+	const content = await renderChildren(ast, Json, depth, true);
 	const val = `[\n${content}\n${getIndent(depth)}]`;
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
 /**
  * JSON Primitives
  */
-Json.register("string", ({ args, textContent }) => {
-	const trim = safeArg({ 
-		args, 
-		key: "trim", 
-		type: "boolean", 
+Json.register("string", ({ args, textContent, inArray }) => {
+	const trim = safeArg({
+		args,
+		key: "trim",
+		type: "boolean",
 		setType: v => v === "true" || v === true,
-		fallBack: false 
+		fallBack: false
 	});
-	const val = escapeString(textContent, trim);
-	return renderMember(args, val);
+	const raw = safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent });
+	const val = escapeString(raw, trim);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
-Json.register("number", ({ args, textContent }) => {
-	const raw = textContent.trim();
+Json.register("number", ({ args, textContent, inArray }) => {
+	const raw = String(safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim();
 	const val = (isNaN(Number(raw)) || raw === "") ? "0" : raw;
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
-Json.register("bool", ({ args, textContent }) => {
-	const raw = textContent.trim().toLowerCase();
+Json.register("bool", ({ args, textContent, inArray }) => {
+	const raw = String(safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim().toLowerCase();
 	const val = (raw === "true" || raw === "1") ? "true" : "false";
-	return renderMember(args, val);
+	return renderMember(args, val, inArray);
 }, { type: "Block", handleAst: true });
 
-Json.register("null", ({ args }) => {
-	return renderMember(args, "null");
+Json.register("null", ({ args, inArray }) => {
+	return renderMember(args, "null", inArray);
 }, { type: "Block", handleAst: true });
 
 export default Json;

package/mappers/languages/jsonc.js

@@ -0,0 +1,82 @@
+import Json, { renderNode, getIndent, renderMember } from "./json.js";
+
+/**
+ * JSONC Mapper - Creates JSON output with comments.
+ * It inherits from the standard JSON mapper and adds comment support.
+ */
+
+async function renderChildren(node, mapper, depth = 0, inArray = false) {
+	let results = [];
+	const childIndent = getIndent(depth + 1);
+
+	for (const child of node.body) {
+		if (child.type === "Block") {
+			const output = await renderNode(child, mapper, depth + 1, inArray);
+			if (output) {
+				results.push({ type: "Block", value: childIndent + output });
+			}
+		} else if (child.type === "Comment") {
+			if (!mapper.options?.removeComments) {
+				results.push({ type: "Comment", value: childIndent + mapper.comment(child.text) });
+			}
+		} else if (child.type === "CommentBlock") {
+			if (!mapper.options?.removeComments) {
+				results.push({ type: "CommentBlock", value: childIndent + mapper.commentBlock(child.text, childIndent) });
+			}
+		}
+	}
+
+	let finalOutput = "";
+	for (let i = 0; i < results.length; i++) {
+		const current = results[i];
+		finalOutput += current.value;
+
+		if (current.type === "Block") {
+			// Add comma if there is another Block later
+			let hasNextBlock = false;
+			for (let j = i + 1; j < results.length; j++) {
+				if (results[j].type === "Block") {
+					hasNextBlock = true;
+					break;
+				}
+			}
+			if (hasNextBlock) finalOutput += ",";
+		}
+
+		if (i < results.length - 1) {
+			finalOutput += "\n";
+		}
+	}
+	return finalOutput;
+}
+
+const Jsonc = Json.clone();
+
+Jsonc.comment = function (text) {
+	return `// ${text}`;
+};
+
+Jsonc.commentBlock = function (text, indent = "  ") {
+	if (text.includes("\n")) {
+		const lines = text.split("\n");
+		return `/*\n${lines.map(line => indent + line).join("\n")}\n${indent}*/`;
+	}
+	return `/* ${text} */`;
+};
+
+// Re-register Object and Array to use the new renderChildren logic
+Jsonc.register(["Object", "object"], async function ({ args, ast, depth = 0, inArray = false }) {
+	if (ast.body.length === 0) return renderMember(args, "{}", inArray);
+	const content = await renderChildren(ast, this, depth, false);
+	const val = `{\n${content}\n${getIndent(depth)}}`;
+	return renderMember(args, val, inArray);
+}, { type: "Block", handleAst: true });
+
+Jsonc.register(["Array", "array"], async function ({ args, ast, depth = 0, inArray = false }) {
+	if (ast.body.length === 0) return renderMember(args, "[]", inArray);
+	const content = await renderChildren(ast, this, depth, true);
+	const val = `[\n${content}\n${getIndent(depth)}]`;
+	return renderMember(args, val, inArray);
+}, { type: "Block", handleAst: true });
+
+export default Jsonc;

package/mappers/languages/markdown.js

@@ -1,9 +1,68 @@
 import Mapper from "../mapper.js";
 import HTML from "./html.js";
 import { registerSharedOutputs } from "../shared/index.js";
-import { BLOCK, TEXT} from "../../core/labels.js";
-import transpiler from "../../core/transpiler.js";
+import { BLOCK, TEXT, INLINE, STATIC_LOGIC } from "../../core/labels.js";
 import { VOID_ELEMENTS } from "../../constants/void_elements.js";
+import evaluator from "../../core/evaluator.js";
+import { matchedValue } from "../../helpers/utils.js";
+
+/**
+ * Helper to manually render AST children inside handleAst blocks,
+ * avoiding the need to call the core transpiler recursively.
+ */
+async function renderNodeAst(astArray, mapperFile) {
+	if (!astArray || !Array.isArray(astArray)) return "";
+	let result = "";
+	for (const node of astArray) {
+		if (node.type === TEXT) {
+			const text = String(node.text || "");
+			result += mapperFile.text(text);
+		} else if (node.type === INLINE) {
+			let target = matchedValue(mapperFile.outputs, node.id) || mapperFile.getUnknownTag(node);
+			if (target) {
+				let inlineValue = String(node.value || "").trim();
+				inlineValue = mapperFile.inlineText(inlineValue, target.options);
+				result += await target.render.call(mapperFile, {
+					nodeType: node.type,
+					args: node.args || {},
+					content: inlineValue,
+					ast: node
+				});
+			} else {
+				result += mapperFile.inlineText(node.value || "", {});
+			}
+		} else if (node.type === STATIC_LOGIC) {
+			try {
+				const val = await evaluator.execute(node.code);
+				if (val !== undefined && typeof val !== "object") {
+					result += mapperFile.text(String(val));
+				}
+			} catch (e) {
+				console.error(`\x1b[31mLogic Error in Markdown mapper:\x1b[0m ${e.message}`);
+			}
+		} else if (node.type === BLOCK) {
+			let target = matchedValue(mapperFile.outputs, node.id) || mapperFile.getUnknownTag(node);
+			if (target) {
+				const isSelfClosing = node.isSelfClosing || false;
+				let content = "";
+				evaluator.pushScope();
+				if (!target.options?.handleAst && node.body) {
+					content = await renderNodeAst(node.body, mapperFile);
+				}
+				const output = await target.render.call(mapperFile, {
+					nodeType: node.type,
+					args: node.args || {},
+					content,
+					ast: node,
+					isSelfClosing
+				});
+				await evaluator.popScope();
+				result += output;
+			}
+		}
+	}
+	return result;
+}
 
 /**
  * The Markdown Mapper used for generating Markdown text.
@@ -62,11 +121,11 @@ const MARKDOWN = Mapper.define({
 
 		return {
 			render: async (ctx) => {
-				const { args, ast } = ctx;
+				const { args, ast, isSelfClosing } = ctx;
 				const body = ast && ast.body ? ast.body : [];
 				const meaningful = body.filter(c => c.type !== TEXT || c.text.trim());
 				const childCount = meaningful.length;
-				const element = this.tag(id).smartAttributes(args, this.customProps);
+				const element = this.tag(id).smartAttributes(args, this.customProps, this.options);
 
 				// Use the transpiler to format the children if any, otherwise use direct content
 				let rawContent;
@@ -77,10 +136,10 @@ const MARKDOWN = Mapper.define({
 					rawContent = node.value || "";
 					rawContent = this.inlineText(rawContent, ctx);
 				} else {
-					rawContent = (await transpiler({ ast: body, mapperFile: this })).trim();
+					rawContent = (await renderNodeAst(body, this)).trim();
 				}
 
-				if (VOID_ELEMENTS.has(id)) {
+				if (isSelfClosing || VOID_ELEMENTS.has(id)) {
 					return element.selfClose();
 				}
 
@@ -115,45 +174,20 @@ MARKDOWN.register("quote", ({ args, content }) => {
 	return md.quote(content, type);
 }, { type: "Block", resolve: true });
 
-/**
- * Unified heading renderer for Markdown and MDX mappers.
- * @param {Object} options - Mapper context and args.
- * @param {string} defaultFormat - Default format ("markdown" or "html").
- * @returns {string} - Rendered heading.
- */
-export function renderHeading({ args, content, ast }, defaultFormat = "markdown") {
-	const heading = ast.id;
-	const format = safeArg({ args, index: 0, key: "format", type: "string", fallBack: defaultFormat });
-	const lvl = heading[1] && !isNaN(Number(heading[1])) ? Number(heading[1]) : 1;
-
-	// Remove formatting arguments before checking for attributes
-	const cleanArgs = { ...args };
-	delete cleanArgs.format;
-	delete cleanArgs["0"]; // Clean positional 'format'
-
-	const hasAttributes = Object.keys(cleanArgs).length > 0;
-
-	// Hybrid Dispatch: Switch to HTML if format is requested OR if attributes are present
-	if (format === "html" || hasAttributes) {
-		let htmlTarget = HTML.get(heading);
-		if (!htmlTarget) {
-			htmlTarget = HTML.getUnknownTag(ast);
-		}
-
-		if (htmlTarget) {
-			return htmlTarget.render.call(this, { args: cleanArgs, content, ast, nodeType: ast.type });
-		}
-	}
-
-	return md.heading(content, lvl);
-}
-
 /**
  * Headings - Renders H1-H6 block headings.
  */
 ["h1", "h2", "h3", "h4", "h5", "h6"].forEach(heading => {
-	MARKDOWN.register(heading, function (ctx) {
-		return renderHeading.call(this, ctx, "markdown");
+	MARKDOWN.register(heading, function ({ args, content, isSelfClosing }) {
+		const format = safeArg({ args, key: "format", type: "string", fallBack: "" });
+		const lvl = heading[1] && !isNaN(Number(heading[1])) ? Number(heading[1]) : 1;
+		if (format.toLowerCase() === "html") {
+			delete args.format;
+			const el = this.tag(heading).smartAttributes(args);
+			if (isSelfClosing) return el.selfClose();
+			return el.body(content);
+		}
+		return this.md.heading(content, lvl);
 	}, { type: "Block" });
 });
 
@@ -215,7 +249,7 @@ MARKDOWN.register(
 	},
 	{
 		type: ["Block", "Inline"],
-		rules: { is_self_closing: false }
+		rules: { is_empty_body: false }
 	}
 );
 
@@ -232,7 +266,7 @@ MARKDOWN.register(
 	},
 	{
 		type: "Block",
-		rules: { is_self_closing: true }
+		rules: { is_empty_body: true }
 	}
 );
 
@@ -247,7 +281,7 @@ MARKDOWN.register(
 	},
 	{
 		type: "Block",
-		rules: { is_self_closing: true }
+		rules: { is_empty_body: true }
 	}
 );
 
@@ -277,7 +311,7 @@ MARKDOWN.register(
 
 			for (const child of cellAst) {
 				if (child.type === BLOCK && (child.id.toLowerCase() === "cell" || child.id.toLowerCase() === "th" || child.id.toLowerCase() === "td")) {
-					const cellContent = await transpiler({ ast: child.body, mapperFile: this });
+					const cellContent = await renderNodeAst(child.body, this);
 					cells.push(cellContent.trim());
 				}
 			}
@@ -294,6 +328,8 @@ MARKDOWN.register(
 				if (rowNode.type === BLOCK && rowNode.id.toLowerCase() === "row") {
 					const rowData = await extractCells(rowNode);
 					if (rowData.length > 0) sectionRows.push(rowData);
+				} else if (rowNode.type === STATIC_LOGIC) {
+					try { await evaluator.execute(rowNode.code); } catch (e) { console.error(`Logic Error: ${e.message}`); }
 				}
 			}
 			return sectionRows;
@@ -303,6 +339,10 @@ MARKDOWN.register(
 			// Remove empty text blocks
 			const tableNodes = ast.body.filter(n => n.type !== TEXT || n.text.trim());
 			for (const node of tableNodes) {
+				if (node.type === STATIC_LOGIC) {
+					try { await evaluator.execute(node.code); } catch (e) { console.error(`Logic Error: ${e.message}`); }
+					continue;
+				}
 				if (node.type !== BLOCK) continue;
 
 				const id = node.id.toLowerCase();
@@ -361,12 +401,12 @@ MARKDOWN.register(["list", "List"], async function ({ ast, args }) {
 			// Trim spaces inside the list item
 			const itemBody = node.body.map(n => n.type === TEXT ? { ...n, text: n.text.replace(/^[ ]+|[ ]+$/gm, "") } : n)
 				.filter(n => n.type !== TEXT || n.text);
-			const itemContent = await transpiler({ ast: itemBody, mapperFile: this });
+			const itemContent = await renderNodeAst(itemBody, this);
 			items.push(itemContent.trim());
 		} else if (node.type === BLOCK && (id === "list")) {
 			// Add nested lists to the latest item
 			if (items.length > 0) {
-				const listContent = await transpiler({ ast: [node], mapperFile: this });
+				const listContent = await renderNodeAst([node], this);
 				items[items.length - 1] += "\n" + listContent;
 			}
 		}
@@ -386,7 +426,7 @@ MARKDOWN.register(["item", "Item"], async function ({ ast }) {
 	// Trim whitespace but keep line breaks
 	const bodyAst = ast.body.map(n => n.type === TEXT ? { ...n, text: n.text.replace(/^[ ]+|[ ]+$/gm, "") } : n)
 		.filter(n => n.type !== TEXT || n.text);
-	return await transpiler({ ast: bodyAst, mapperFile: this });
+	return await renderNodeAst(bodyAst, this);
 }, { type: "Block", handleAst: true, trimAndWrapBlocks: false });
 
 /**

package/mappers/languages/mdx.js

@@ -1,5 +1,5 @@
 import Mapper from "../mapper.js";
-import MARKDOWN, { renderHeading } from "./markdown.js";
+import MARKDOWN from "./markdown.js";
 import { VOID_ELEMENTS } from "../../constants/void_elements.js";
 
 /**
@@ -28,14 +28,14 @@ const MDX = Mapper.define({
 
 		return {
 			render: (ctx) => {
-				const { args, content } = ctx;
+				const { args, content, isSelfClosing } = ctx;
 				const element = this.tag(tagName).jsxProps(args);
-				return isVoid ? element.selfClose() : element.body(content);
+				return (isSelfClosing || isVoid) ? element.selfClose() : element.body(content);
 			},
 			options: {
 				type: isVoid ? "Block" : (isCodeStyleOrScript ? ["Block", "AtBlock"] : ["Block", "Inline", "AtBlock"]),
 				escape: !isCodeStyleOrScript,
-				rules: { is_self_closing: isVoid }
+				rules: { is_empty_body: isVoid }
 			}
 		};
 	},
@@ -48,14 +48,22 @@ const MDX = Mapper.define({
 	 * Formats a plain text node with Markdown escaping.
 	 */
 	text(text, options) {
-		return MARKDOWN.text.call(this, text, options);
+		let out = text;
+		if (options?.escape !== false) {
+			out = this.escapeHTML(out);
+		}
+		return out;
 	},
 
 	/**
 	 * Formats inline content before rendering, respecting explicit escape flags.
 	 */
 	inlineText(text, options) {
-		return MARKDOWN.inlineText.call(this, text, options);
+		let out = text;
+		if (options?.escape !== false) {
+			out = this.escapeHTML(out);
+		}
+		return out;
 	},
 
 	/**
@@ -66,9 +74,6 @@ const MDX = Mapper.define({
 		if (options?.escape !== false) {
 			out = this.escapeHTML(out);
 		}
-		if (out.includes('\n')) {
-			out = '\n' + out + '\n';
-		}
 		return out;
 	}
 });
@@ -76,13 +81,17 @@ const MDX = Mapper.define({
 const { tag } = MDX;
 
 MDX.inherit(MARKDOWN);
-MDX.md = MARKDOWN.md; // Provide the Markdown escaping tool
+MDX.md = MARKDOWN.md;
 
-// MDX defaults to HTML tags for headings to ensure high-fidelity JSX output
-["h1", "h2", "h3", "h4", "h5", "h6"].forEach(heading => {
-	MDX.register(heading, function (ctx) {
-		return renderHeading.call(this, ctx, "html");
-	}, { type: "Block" });
+["h1", "h2", "h3", "h4", "h5", "h6"].forEach(h => {
+	MDX.register(h, function ({ args, content }) {
+		const format = this.safeArg({ args, key: "format", fallBack: "" });
+		if (format === "md" || format === "markdown") {
+			return this.md.heading(content, h.slice(1) || 1);
+		}
+		delete args.format;
+		return tag(h).jsxProps(args).body(content);
+	});
 });
 
 /**
@@ -92,4 +101,30 @@ MDX.register("mdx", ({ content }) => {
 	return content;
 }, { escape: false, type: "AtBlock" });
 
+// Inline CSS tag (Moved from shared)
+MDX.register("css", ({ args, content }) => {
+	// Compile style from named arguments (keys that are not numeric digits)
+	const namedStyle = Object.keys(args)
+		.filter(k => isNaN(parseInt(k)))
+		.map(k => `${k}:${args[k]}`)
+		.join(";");
+
+	// Fetch positional style string (index 0) or "style" key if present
+	let positionalStyle = MDX.safeArg({ args, index: 0, key: "style", fallBack: "" });
+
+	// Filter out positional styles that are just duplicates of named arguments
+	const hasDuplicateNamed = Object.keys(args)
+		.filter(k => isNaN(parseInt(k)))
+		.some(k => args[k] === positionalStyle);
+
+	if (hasDuplicateNamed) {
+		positionalStyle = "";
+	}
+
+	// Combine both together
+	let style = [positionalStyle, namedStyle].filter(s => s.trim()).join(";");
+
+	return MDX.tag("span").jsxProps({ style }).body(content);
+}, { type: "Inline" });
+
 export default MDX;