sommark 4.5.2 → 5.0.0

package/mappers/languages/json.js

@@ -1,185 +1,103 @@
 import Mapper from "../mapper.js";
-import { getPositionalArgs, matchedValue, safeArg } from "../../helpers/utils.js";
+import { getPositionalArgs, safeArg } from "../../helpers/utils.js";
+import { transpilerError } from "../../core/errors.js";
 
-/**
- * JSON Mapper - Creates JSON output.
- * It manages the structure manually using 'handleAst: true'.
- */
+const ITEM_SEP = "\x1F";
 
-/**
- * Returns a string representing the specified indentation level.
- */
 export function getIndent(depth) {
 	return "  ".repeat(depth);
 }
 
-/**
- * Escapes a string for use in a JSON property or value.
- * @param {string} str - The string to escape.
- * @param {boolean} [trim=false] - Whether to trim the string.
- */
 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.
- */
-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 === "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;
-}
-
-/**
- * Resolves the key-value pairing for a JSON member.
- */
-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
-
-	if (key) {
-		return `${escapeString(key)}: ${value}`;
-	}
+export function renderMember(props, value, inArray = false) {
+	if (inArray) return value + ITEM_SEP;
+	const posArgs = getPositionalArgs(props);
+	const key = props.key || posArgs[0];
+	if (key) return `${escapeString(key)}: ${value}` + ITEM_SEP;
 	return value;
 }
 
-/**
- * Formats a given node and tracks its indentation.
- */
-export async function renderNode(node, mapper, depth = 0, inArray = false) {
-	const target = matchedValue(mapper.outputs, node.id) || mapper.getUnknownTag(node);
-	if (!target) return "";
-
-	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,
-		inArray
-	});
-	await evaluator.popScope();
-	return output;
-}
-
-/**
- * Formats the children of a node into a neat list.
- */
-export async function renderChildren(node, mapper, depth = 0, inArray = false) {
-	let results = [];
-	const childIndent = getIndent(depth + 1);
+const Json = Mapper.define({});
 
-	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 });
-			}
-		}
+Json.register(["Object", "object"], async function ({ props, ast, depth = 0, inArray = false, renderChild }) {
+	let combined = "";
+	for (const child of ast.body) {
+		const out = await renderChild(child, { depth: depth + 1, inArray: false });
+		if (out) combined += out;
 	}
-
-	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";
-		}
+	const parts = combined.split(ITEM_SEP).map(v => v.trim()).filter(v => v !== "");
+	const value = parts.length === 0
+		? "{}"
+		: `{\n${parts.map(p => getIndent(depth + 1) + p).join(",\n")}\n${getIndent(depth)}}`;
+	return renderMember(props, value, inArray);
+}, { handleAst: true });
+
+Json.register(["Array", "array"], async function ({ props, ast, depth = 0, inArray = false, renderChild }) {
+	let combined = "";
+	for (const child of ast.body) {
+		const out = await renderChild(child, { depth: depth + 1, inArray: true });
+		if (out) combined += out;
 	}
-	return finalOutput;
-}
-
-const Json = Mapper.define({});
-
-/**
- * The JSON object node rule.
- */
-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, inArray);
-}, { type: "Block", handleAst: true });
-
-/**
- * The JSON array node rule.
- */
-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, inArray);
-}, { type: "Block", handleAst: true });
-
-/**
- * JSON Primitives
- */
-Json.register("string", ({ args, textContent, inArray }) => {
+	const parts = combined.split(ITEM_SEP).map(v => v.trim()).filter(v => v !== "");
+	const value = parts.length === 0
+		? "[]"
+		: `[\n${parts.map(p => getIndent(depth + 1) + p).join(",\n")}\n${getIndent(depth)}]`;
+	return renderMember(props, value, inArray);
+}, { handleAst: true });
+
+Json.register(["string", "str"], ({ props, textContent, inArray }) => {
 	const trim = safeArg({
-		args,
+		props,
 		key: "trim",
 		type: "boolean",
 		setType: v => v === "true" || v === true,
 		fallBack: false
 	});
-	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 });
+	const raw = safeArg({ props, index: inArray ? 0 : undefined, key: "value", fallBack: textContent });
+	return renderMember(props, escapeString(raw, trim), inArray);
+}, { handleAst: true });
 
-Json.register("number", ({ args, textContent, inArray }) => {
-	const raw = String(safeArg({ args, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim();
+Json.register("number", ({ props, textContent, inArray }) => {
+	const raw = String(safeArg({ props, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim();
 	const val = (isNaN(Number(raw)) || raw === "") ? "0" : raw;
-	return renderMember(args, val, inArray);
-}, { type: "Block", handleAst: true });
-
-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, inArray);
-}, { type: "Block", handleAst: true });
-
-Json.register("null", ({ args, inArray }) => {
-	return renderMember(args, "null", inArray);
-}, { type: "Block", handleAst: true });
+	return renderMember(props, val, inArray);
+}, { handleAst: true });
+
+Json.register("bool", ({ props, textContent, inArray }) => {
+	const raw = String(safeArg({ props, index: inArray ? 0 : undefined, key: "value", fallBack: textContent })).trim().toLowerCase();
+	return renderMember(props, (raw === "true" || raw === "1") ? "true" : "false", inArray);
+}, { handleAst: true });
+
+Json.register("null", ({ props, inArray }) => {
+	return renderMember(props, "null", inArray);
+}, { handleAst: true });
+
+Json.getUnknownTag = function (node) {
+	const key = node.id;
+	return {
+		render({ props, textContent, inArray = false }) {
+			if (inArray) {
+				transpilerError(
+					`Unknown tag '<$yellow:[${key}]$>' cannot be used inside <$yellow:[Array]$>.{N}Use <$cyan:[string]$>, <$cyan:[number]$>, <$cyan:[bool]$>, or <$cyan:[null]$> instead.`
+				);
+			}
+			const raw = String(
+				safeArg({ props, index: 0, key: "value", fallBack: textContent.trim() })
+			).trim();
+			let val;
+			if (raw === "null")                             val = "null";
+			else if (raw === "true" || raw === "false")     val = raw;
+			else if (raw !== "" && !isNaN(Number(raw)))     val = raw;
+			else                                            val = escapeString(raw);
+			return `${escapeString(key)}: ${val}` + ITEM_SEP;
+		},
+		options: { handleAst: true }
+	};
+};
 
 export default Json;

package/mappers/languages/jsonc.js

@@ -1,54 +1,6 @@
-import Json, { renderNode, getIndent, renderMember } from "./json.js";
+import Json, { 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 ITEM_SEP = "\x1F";
 
 const Jsonc = Json.clone();
 
@@ -64,19 +16,25 @@ Jsonc.commentBlock = function (text, 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 });
+async function renderStructure(props, ast, depth, inArray, childInArray, openBracket, closeBracket, renderChild) {
+	let combined = "";
+	for (const child of ast.body) {
+		const out = await renderChild(child, { depth: depth + 1, inArray: childInArray });
+		if (out) combined += out;
+	}
+	const parts = combined.split(ITEM_SEP).map(v => v.trim()).filter(v => v !== "");
+	const value = parts.length === 0
+		? `${openBracket}${closeBracket}`
+		: `${openBracket}\n${parts.map(p => getIndent(depth + 1) + p).join(",\n")}\n${getIndent(depth)}${closeBracket}`;
+	return renderMember(props, value, inArray);
+}
+
+Jsonc.register(["Object", "object"], async function ({ props, ast, depth = 0, inArray = false, renderChild }) {
+	return renderStructure(props, ast, depth, inArray, false, "{", "}", renderChild);
+}, { 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 });
+Jsonc.register(["Array", "array"], async function ({ props, ast, depth = 0, inArray = false, renderChild }) {
+	return renderStructure(props, ast, depth, inArray, true, "[", "]", renderChild);
+}, { handleAst: true });
 
 export default Jsonc;