sommark 2.3.2 → 3.0.0

package/mappers/languages/json.js

@@ -2,7 +2,6 @@ import Mapper from "../mapper.js";
 import { TEXT } from "../../core/labels.js";
 import { transpilerError } from "../../core/errors.js";
 
-const Json = new Mapper();
 
 // ========================================================================== //
 //  Helpers                                                                   //
@@ -156,17 +155,37 @@ function renderInline(node, parentType) {
 	}
 }
 
+class JsonMapper extends Mapper {
+	constructor() {
+		super();
+	}
+
+	formatOutput(output) {
+		try {
+			return JSON.parse(JSON.stringify(output));
+		} catch (e) {
+			transpilerError([
+				"{line}<$red:JSON Format Error:$> ",
+				`<$yellow:Failed to parse generated JSON output.$>{N}<$cyan:Reason: $> <$magenta:'${e.message}'$>{line}`
+			]);
+			return output;
+		}
+	}
+}
+
+const Json = new JsonMapper();
+
 // ========================================================================== //
 //  Main Registration                                                         //
 // ========================================================================== //
 
 const noop = () => "";
-Json.register(["Object", "Array"], noop);
-Json.register(["string", "number", "bool", "null", "array", "none"], noop);
+Json.register(["Object", "Array"], noop, { type: "Block" });
+Json.register(["string", "number", "bool", "null", "array", "none"], noop, { type: "Inline" });
 
 Json.register("Json", ({ args, content, ast }) => {
 	if (!ast) return "";
 	return processNode(ast, null);
-});
+}, { type: "Block" });
 
 export default Json;

package/mappers/languages/markdown.js

@@ -1,112 +1,126 @@
 import Mapper from "../mapper.js";
-const MARKDOWN = new Mapper();
+import HTML from "./html.js";
+import { todo } from "../../helpers/utils.js";
+
+class MarkdownMapper extends Mapper {
+	constructor() {
+		super();
+	}
+	comment(text) {
+		return `<!--${text.replace("#", "")}-->\n`;
+	}
+	formatOutput(output, includeDocument) {
+		const todoRegex = /@@TODO_BLOCK:([\s\S]*?):([\s\S]*?)@@/g;
+		const statusMarkers = ["done", "x", "X", "-", ""];
+		return output.replace(todoRegex, (match, body, arg0) => {
+			const bodyTrimmed = body.trim().toLowerCase();
+			const arg0Trimmed = arg0.trim().toLowerCase();
+			
+			const bodyIsStatus = statusMarkers.includes(bodyTrimmed);
+			const arg0IsStatus = statusMarkers.includes(arg0Trimmed);
+			
+			let finalStatus = arg0; // Default: arg is status
+			let finalTask = body;   // Default: body is task
+			
+			if (bodyIsStatus && !arg0IsStatus) {
+				finalStatus = body;
+				finalTask = arg0;
+			}
+			
+			return this.md.todo(todo(finalStatus), finalTask);
+		});
+	}
+}
+
+const MARKDOWN = new MarkdownMapper();
+MARKDOWN.inherit(HTML);
 const { md, safeArg } = MARKDOWN;
 // Block
-MARKDOWN.register(["Block", "block", "Section", "section"], ({ content }) => {
+MARKDOWN.register("Block", ({ content }) => {
 	return content;
+}, { type: "Block" });
+// Quote
+MARKDOWN.register(["quote", "blockquote"], ({ content }) => {
+	return "\n" + content.trimEnd()
+		.split("\n")
+		.map(line => `> ${line}`)
+		.join("\n");
+}, { type: "Block" });
+// Headings (Block only, like HTML mapper)
+["h1", "h2", "h3", "h4", "h5", "h6"].forEach(heading => {
+	MARKDOWN.register(heading, ({ content }) => {
+		const lvl = heading[1] && typeof Number(heading[1]) === "number" ? heading[1] : 1;
+		return md.heading(content, lvl);
+	}, { type: "Block" });
 });
-// Headings
-MARKDOWN.register(
-	["Heading", "heading"],
-	({ args, content }) => {
-		const level = safeArg(args, 0, "level", "number", Number, 1);
-		const title = safeArg(args, 1, "title", null, null, "");
-		return md.heading(title, level) + content;
-	},
-	{
-		rules: {
-			type: "Block"
-		}
-	}
-);
-// Inline Headings
-["h1", "h2", "h3", "h4", "h5", "h6"].forEach(
-	heading => {
-		MARKDOWN.register(heading, ({ content }) => {
-			const lvl = heading[1] && typeof Number(heading[1]) === "number" ? heading[1] : 1;
-			return md.heading(content, lvl);
-		});
-	},
-	{
-		rules: {
-			type: "Inline"
-		}
-	}
-);
 // Bold
-MARKDOWN.register(["bold", "b"], ({ content }) => {
+MARKDOWN.register("bold", ({ content }) => {
 	return md.bold(content);
-});
+}, { type: "any" });
 // Italic
-MARKDOWN.register(["italic", "i"], ({ content }) => {
+MARKDOWN.register("italic", ({ content }) => {
 	return md.italic(content);
-});
+}, { type: "any" });
 // Bold and Italic (emphasis)
-MARKDOWN.register(["emphasis", "e"], ({ content }) => {
+MARKDOWN.register("emphasis", ({ content }) => {
 	return md.emphasis(content);
-});
+}, { type: "any" });
 // Code Blocks
 MARKDOWN.register(
-	["code", "Code", "codeBlock", "CodeBlock"],
+	"Code",
 	({ args, content }) => {
 		const lang = safeArg(args, 0, "lang", null, null, "text");
 		return md.codeBlock(content, lang);
 	},
 	{
 		escape: false,
-		rules: {
-			type: "AtBlock"
-		}
+		type: "AtBlock"
 	}
 );
 // Link
 MARKDOWN.register(
-	["link", "Link"],
-	({ args, content }) => {
-		const url = safeArg(args, 0, "url", null, null, "");
+	"link",
+	({ args }) => {
+		const url = safeArg(args, 0, "src", null, null, "");
 		const title = safeArg(args, 1, "title", null, null, "");
-		return md.url("link", content, url, title);
+		const text = safeArg(args, 2, "alt", null, null, "");
+		return md.url("link", text, url, title);
 	},
 	{
-		rules: {
-			type: "Inline"
-		}
+		type: "Block"
 	}
 );
 // Image
 MARKDOWN.register(
-	["image", "Image"],
-	({ args, content }) => {
-		const url = safeArg(args, 0, "url", null, null, "");
+	"image",
+	({ args }) => {
+		const url = safeArg(args, 0, "src", null, null, "");
 		const title = safeArg(args, 1, "title", null, null, "");
-		return md.url("image", content, url, title);
+		const alt = safeArg(args, 2, "alt", null, null, "");
+		return md.url("image", alt, url, title);
 	},
 	{
-		rules: {
-			type: "Inline"
-		}
+		type: "Block"
 	}
 );
 // Horizontal Rule
 MARKDOWN.register(
-	["horizontal", "hr", "h"],
+	"hr",
 	({ args }) => {
 		const fmt = safeArg(args, 0, undefined, null, null, "*");
 		return md.horizontal(fmt);
 	},
 	{
-		rules: {
-			type: "Block"
-		}
+		type: "Block"
 	}
 );
 // Escape Characters
-MARKDOWN.register(["escape", "Escape", "s"], ({ content }) => {
+MARKDOWN.register("escape", ({ content }) => {
 	return md.escape(content);
-});
+}, { type: "any" });
 // Table
 MARKDOWN.register(
-	"table",
+	"Table",
 	({ args, content }) => {
 		return md.table(
 			args,
@@ -117,20 +131,27 @@ MARKDOWN.register(
 				.map(line => line.trim())
 		);
 	},
-	{ escape: false, rules: { type: "AtBlock" } }
+	{ escape: false, type: "AtBlock" }
 );
 // List
 MARKDOWN.register(
-	["list", "List"],
+	"list",
 	({ content }) => {
 		return content;
 	},
-	{ escape: false, rules: { type: "AtBlock" } }
+	{ escape: false, type: "AtBlock" }
 );
 // Todo
 MARKDOWN.register("todo", ({ args, content }) => {
-	const checked = content === "x" ? true : false;
-	const task = safeArg(args, 0, "task", null, null, "");
+	const isPlaceholder = content.includes("__SOMMARK_BODY_PLACEHOLDER_");
+	if (isPlaceholder) {
+		return `@@TODO_BLOCK:${content}:${args[0] || ""}@@`;
+	}
+	const statusMarkers = ["done", "x", "X", "-", ""];
+	const isInline = !isPlaceholder && statusMarkers.includes(content.trim().toLowerCase()) && args.length > 0;
+	const status = isInline ? content : (args[0] || "");
+	const task = isInline ? (args[0] || "") : content;
+	const checked = todo(status);
 	return md.todo(checked, task);
-});
+}, { type: "any" });
 export default MARKDOWN;

package/mappers/languages/mdx.js

@@ -1,5 +1,133 @@
 import Mapper from "../mapper.js";
 import MARKDOWN from "./markdown.js";
-const MDX = new Mapper();
-MDX.outputs = MARKDOWN.outputs;
+import { HTML_TAGS } from "../../constants/html_tags.js";
+import { HTML_PROPS } from "../../constants/html_props.js";
+import { VOID_ELEMENTS } from "../../constants/void_elements.js";
+import kebabize from "../../helpers/kebabize.js";
+
+class MdxMapper extends Mapper {
+	constructor() {
+		super();
+	}
+	comment(text) {
+		return `{/*${text.replace("#", "")} */}\n`;
+	}
+	getUnknownTag(node) {
+		const tagName = node.id;
+		return {
+			render: ({ args, content }) => {
+				const element = this.tag(tagName);
+				element.props(this.jsxProps(args, tagName));
+				return element.body(content);
+			}
+		};
+	}
+
+	jsxProps(args, tagName = "div") {
+		const jsxProps = [];
+		const styleObj = {};
+		const isHtmlTag = HTML_TAGS.has(tagName.toLowerCase());
+
+		const keys = Object.keys(args).filter(arg => isNaN(arg));
+		keys.forEach(key => {
+			let val = args[key];
+			const isEvent = key.toLowerCase().startsWith("on");
+
+			let k = key;
+			if (k === "class") k = "className";
+
+			// Quote stripping
+			if (typeof val === "string" && ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'")))) {
+				val = val.slice(1, -1);
+			}
+
+			if (k === "style") {
+				if (typeof val === "string") {
+					const pairs = val.includes(";") ? val.split(";") : val.split(",");
+					pairs.forEach(pair => {
+						let [prop, value] = pair.split(":").map(s => s.trim());
+						if (prop && value) {
+							const camelProp = prop.replace(/-([a-z])/g, g => g[1].toUpperCase());
+							styleObj[camelProp] = value;
+						}
+					});
+				} else if (typeof val === "object") {
+					Object.assign(styleObj, val);
+				}
+			} else {
+				// Detection for expressions
+				const isBoolean = val === "true" || val === "false" || typeof val === "boolean";
+				const isNumeric = val !== "" && !isNaN(val) && typeof val !== "boolean";
+				const looksLikeExpression = typeof val === "string" && 
+					(/[0-9]/.test(val) && /[+\-*/%()]/.test(val)); // Math expression detection
+
+				const shouldBeJSXExpression = isEvent || isBoolean || isNumeric || looksLikeExpression;
+
+				let finalVal = val;
+				if (val === "true") finalVal = true;
+				if (val === "false") finalVal = false;
+				if (isNumeric && typeof val === "string") finalVal = Number(val);
+
+				jsxProps.push({ 
+					__type__: shouldBeJSXExpression ? "other" : "string", 
+					[k]: finalVal 
+				});
+			}
+		});
+
+		if (Object.keys(styleObj).length > 0) {
+			const styleStr = JSON.stringify(styleObj).replace(/"/g, "'").replace(/'([^']+)':/g, '$1:');
+			jsxProps.push({ __type__: "other", style: styleStr });
+		}
+
+		return jsxProps;
+	}
+}
+
+const MDX = new MdxMapper();
+const { tag } = MDX;
+
+MDX.inherit(MARKDOWN);
+
+// Block for raw MDX content (ESM, etc.)
+MDX.register("mdx", ({ content }) => content, { escape: false, type: "Block" });
+
+// Re-register HTML tags to use jsxProps
+HTML_TAGS.forEach(tagName => {
+	const capitalized = tagName.charAt(0).toUpperCase() + tagName.slice(1);
+
+	// Register even if it exists in MARKDOWN to override it with JSX version
+	const idsToRegister = [tagName, capitalized];
+
+	MDX.register(
+		idsToRegister,
+		({ args, content }) => {
+			const element = tag(tagName);
+
+			// Auto-ID for Headings
+			if (/^h[1-6]$/i.test(tagName) && !args.id && content && /^[A-Za-z0-9]/.test(content)) {
+				const id = content
+					.toString()
+					.toLowerCase()
+					.replace(/[^\w\s-]/g, "")
+					.replace(/\s+/g, "-");
+				args.id = id;
+			}
+
+			element.props(MDX.jsxProps(args, tagName));
+
+			if (VOID_ELEMENTS.has(tagName)) {
+				return element.selfClose();
+			}
+			return element.body(content);
+		},
+		{
+			type: VOID_ELEMENTS.has(tagName) ? "Block" : ["Block", "Inline"],
+			rules: {
+				is_self_closing: VOID_ELEMENTS.has(tagName)
+			}
+		}
+	);
+});
+
 export default MDX;