sommark 4.0.0 → 4.0.2

package/cli/commands/build.js

@@ -20,14 +20,14 @@ import { transpile } from "../helpers/transpile.js";
  * @param {string} outputFile - Output filename (without extension).
  * @param {string} format - Target format (html, markdown, etc.).
  * @param {string} sourcePath - Path to the source .smark file.
- * @param {Mapper|null} mappingFile - Custom mapped rules.
+ * @param {Mapper|null} mapperFile - Custom mapped rules.
  * @returns {Promise<string>} - The full path to the created file.
  */
-async function generateOutput(outputDir, outputFile, format, sourcePath, mappingFile, config) {
+async function generateOutput(outputDir, outputFile, format, sourcePath, mapperFile, config) {
     let source_code = await readContent(sourcePath);
     source_code = source_code.toString();
     const absolutePath = path.resolve(process.cwd(), sourcePath);
-    const output = await transpile({ src: source_code, format, filename: absolutePath, mappingFile, config });
+    const output = await transpile({ src: source_code, format, filename: absolutePath, mapperFile, config });
     const finalPath = path.join(outputDir, `${outputFile}.${extensions[format]}`);
     await createFile(outputDir, `${outputFile}.${extensions[format]}`, output);
     return finalPath;
@@ -75,10 +75,10 @@ export async function runBuild(format_option, sourcePath, outputFlag, outputFile
                 // Configuration for output
                 let finalOutputFile = config.outputFile;
                 let finalOutputDir = config.outputDir;
-                let mappingFile = config.mappingFile;
+                let mapperFile = config.mapperFile || config.mappingFile;
 
-                if (!mappingFile) {
-                    mappingFile = format === "html" ? HTML : format === "markdown" ? MARKDOWN : format === "mdx" ? MDX : format === "json" ? Json : format === "xml" ? XML : null;
+                if (!mapperFile) {
+                    mapperFile = format === "html" ? HTML : format === "markdown" ? MARKDOWN : format === "mdx" ? MDX : format === "json" ? Json : format === "xml" ? XML : null;
                 }
 
                 // CLI Overrides
@@ -89,7 +89,7 @@ export async function runBuild(format_option, sourcePath, outputFlag, outputFile
                     }
                 }
 
-                const createdFilePath = await generateOutput(finalOutputDir, finalOutputFile, format, sourcePath, mappingFile, config);
+                const createdFilePath = await generateOutput(finalOutputDir, finalOutputFile, format, sourcePath, mapperFile, config);
                 const stats = await fs.stat(createdFilePath);
                 const date = new Date().toLocaleString();
 

package/cli/helpers/transpile.js

@@ -15,23 +15,31 @@ const default_mapperFiles = { [htmlFormat]: HTML, [markdownFormat]: MARKDOWN, [m
 // ========================================================================== //
 //  Transpile Function                                                        //
 // ========================================================================== //
-export async function transpile({ src, format, filename = null, mappingFile = "", config = null }) {
+export async function transpile({ src, format, filename = null, mapperFile = "", config = null }) {
     const finalConfig = config || await loadConfig(filename);
-    let finalMapper = mappingFile;
+    let finalMapper = mapperFile;
 
     // 1. Find the Mapping File
-    if (typeof mappingFile !== "object" || mappingFile === null) {
-        if (finalConfig.mappingFile) {
-            finalMapper = finalConfig.mappingFile;
+    if (typeof mapperFile !== "object" || mapperFile === null) {
+        // Support both names from config
+        const configMapper = finalConfig.mapperFile || finalConfig.mappingFile;
+        
+        if (configMapper) {
+            finalMapper = configMapper;
         } else {
             finalMapper = default_mapperFiles[format];
         }
 
         // Custom Mapper (String Path)
-        if (typeof finalMapper === "string" && finalMapper !== "" && (await isExist(finalMapper))) {
-            const mappingFileURL = pathToFileURL(path.resolve(process.cwd(), finalMapper)).href;
-            const loadedMapper = await import(mappingFileURL);
-            finalMapper = loadedMapper.default;
+        if (typeof finalMapper === "string" && finalMapper !== "") {
+            const baseDir = finalConfig.resolvedConfigPath ? path.dirname(finalConfig.resolvedConfigPath) : process.cwd();
+            const absoluteMapperPath = path.resolve(baseDir, finalMapper);
+            
+            if (await isExist(absoluteMapperPath)) {
+                const mapperFileURL = `${pathToFileURL(absoluteMapperPath).href}?t=${Date.now()}`;
+                const loadedMapper = await import(mapperFileURL);
+                finalMapper = loadedMapper.default;
+            }
         }
     }
 

package/core/helpers/config-loader.js

@@ -48,28 +48,49 @@ export async function findAndLoadConfig(targetPath) {
 		}
 	}
 
-	// 2. Check the current folder
+	// 2. Check the target directory
 	if (!configPath) {
 		const localConfig = path.join(startDir, CONFIG_FILE_NAME);
 		try {
 			await fs.access(localConfig);
 			configPath = localConfig;
 		} catch {
-			// No local config found
+			// No local config found in target dir
+		}
+	}
+
+	// 3. Check the current working directory (if different from target dir)
+	if (!configPath && startDir !== process.cwd()) {
+		const cwdConfig = path.join(process.cwd(), CONFIG_FILE_NAME);
+		try {
+			await fs.access(cwdConfig);
+			configPath = cwdConfig;
+		} catch {
+			// No config found in CWD
 		}
 	}
 	
 	const defaultConfig = {
 		outputFile: "output",
 		outputDir: startDir,
-		mappingFile: null,
+		mapperFile: null,
 		removeComments: true,
+		placeholders: {},
+		customProps: [],
 	};
 
 	if (configPath) {
 		const loadedConfig = await loadConfigFile(configPath);
 		if (loadedConfig) {
-			const finalConfig = { ...defaultConfig, ...loadedConfig, resolvedConfigPath: configPath };
+			// Support both mapperFile and mappingFile (backwards compatibility)
+			const finalMapper = loadedConfig.mapperFile || loadedConfig.mappingFile || defaultConfig.mapperFile;
+			
+			const finalConfig = { 
+				...defaultConfig, 
+				...loadedConfig, 
+				mapperFile: finalMapper,
+				resolvedConfigPath: configPath 
+			};
 			if (loadedConfig.outputDir) {
 				const configDir = path.dirname(configPath);
 				finalConfig.outputDir = path.resolve(configDir, loadedConfig.outputDir);

package/core/transpiler.js

@@ -2,6 +2,7 @@ import { BLOCK, TEXT, INLINE, ATBLOCK, COMMENT } from "./labels.js";
 import { transpilerError } from "./errors.js";
 import { textFormat, htmlFormat, markdownFormat, mdxFormat, xmlFormat } from "./formats.js";
 import { matchedValue } from "../helpers/utils.js";
+import { dedentBy } from "../helpers/dedent.js";
 
 /**
  * SomMark Transpiler
@@ -84,7 +85,7 @@ async function generateOutput(ast, i, format, mapper_file) {
 		const textContent = getNodeText(node);
 
 		let content = (node.body?.length === 0) ? "" :
-			(node.type === ATBLOCK ? (node.content || "") :
+			(node.type === ATBLOCK ? dedentBy(node.content || "", node.range?.start?.character || 0).trim() :
 				(node.type === INLINE ? (node.value || "") : BODY_PLACEHOLDER));
 
 		// Apply pipelines to format literal values
@@ -132,7 +133,9 @@ async function generateOutput(ast, i, format, mapper_file) {
 				switch (body_node.type) {
 					case TEXT:
 						const text = String(body_node.text || "");
-						bodyOutput = mapper_file ? mapper_file.text(text, target?.options) : text;
+						// Dedent text relative to the parent block's indentation
+						const localDedentedText = dedentBy(text, node.range?.start?.character || 0);
+						bodyOutput = mapper_file ? mapper_file.text(localDedentedText, target?.options) : localDedentedText;
 						break;
 
 					case INLINE:
@@ -160,15 +163,14 @@ async function generateOutput(ast, i, format, mapper_file) {
 						break;
 
 					case ATBLOCK:
-						console.log(`[TRANSPILER] Processing ATBLOCK: ${body_node.id}`);
 						let atTarget = matchedValue(mapper_file.outputs, body_node.id);
 						if (!atTarget) {
 							atTarget = mapper_file.getUnknownTag(body_node);
 						}
 
-						let atContent = String(body_node.content || "").trim();
+						// AtBlocks handle their own absolute dedenting
+						let atContent = dedentBy(body_node.content || "", body_node.range?.start?.character || 0).trim();
 						if (mapper_file) {
-							console.log(`[TRANSPILER] Calling atBlockBody for ${body_node.id}`);
 							atContent = mapper_file.atBlockBody(atContent, atTarget?.options || {});
 						}
 
@@ -195,7 +197,6 @@ async function generateOutput(ast, i, format, mapper_file) {
 			}
 		}
 
-		// Trim only leading/trailing newlines and their surrounding spaces to preserve indentation
 		const finalContext = effectiveTrimAndWrap ? context.replace(/^\s*[\r\n]+|[\r\n]+\s*$/g, "") : context;
 
 		if (result.includes(BODY_PLACEHOLDER)) {

package/helpers/dedent.js

@@ -0,0 +1,19 @@
+/**
+ * Dedents a string by a given amount of characters.
+ * 
+ * @param {string} str - The string to dedent.
+ * @param {number} amount - The number of characters to remove from the start of each line.
+ * @returns {string} - The dedented string.
+ */
+export function dedentBy(str, amount) {
+	if (!str || amount <= 0) return str;
+	const lines = str.split("\n");
+	const dedentedLines = lines.map((line) => {
+		let count = 0;
+		while (count < amount && (line[count] === " " || line[count] === "\t")) {
+			count++;
+		}
+		return line.slice(count);
+	});
+	return dedentedLines.join("\n");
+}

package/index.js

@@ -34,17 +34,16 @@ class SomMark {
 	 * @param {string} [options.filename="anonymous"] - The name of the file, used for errors and settings.
 	 * @param {boolean} [options.removeComments=true] - If true, comments will be removed from the final code.
 	 * @param {Object} [options.placeholders={}] - Values to use for {placeholders}.
-	 * @param {Object} [options.placeholder={}] - Alias for placeholders (backward compatibility).
 	 * @param {Array<string>} [options.customProps=[]] - Allowed custom HTML attributes.
 	 * @param {Array<string>} [options.importStack=[]] - Tracking for circular dependencies.
 	 */
-	constructor({ src, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholder = {}, placeholders = {}, customProps = [], importStack = [] }) {
+	constructor({ src, format, mapperFile = null, filename = "anonymous", removeComments = true, placeholders = {}, customProps = [], importStack = [] }) {
 		this.src = src;
 		this.targetFormat = format;
 		this.mapperFile = mapperFile;
 		this.filename = filename;
 		this.removeComments = removeComments;
-		this.placeholders = { ...placeholder, ...placeholders };
+		this.placeholders = placeholders;
 		this.customProps = customProps;
 		this.importStack = importStack;
 		this.warnings = [];
@@ -81,16 +80,6 @@ class SomMark {
 		this._initializeMappers();
 	}
 
-	/**
-	 * Backward compatibility alias for placeholders.
-	 */
-	get placeholder() {
-		return this.placeholders;
-	}
-
-	set placeholder(val) {
-		this.placeholders = val;
-	}
 
 	/**
 	 * Adds a new rule or changes an existing one.
@@ -278,16 +267,15 @@ async function parse(src, filename = "anonymous") {
  * @param {Mapper|null} [options.mapperFile=null] - Custom rules for formatting.
  * @param {boolean} [options.removeComments=true] - Strip comments.
  * @param {Object} [options.placeholders={}] - Global placeholders.
- * @param {Object} [options.placeholder={}] - Alias for placeholders.
  * @param {Array<string>} [options.customProps=[]] - Custom attribute whitelist.
  * @returns {Promise<string>} - Transpiled output.
  */
 async function transpile(options = {}) {
-	const { src, format = htmlFormat, filename = "anonymous", mapperFile = null, removeComments = true, placeholder = {}, placeholders = {}, customProps = [] } = options;
+	const { src, format = htmlFormat, filename = "anonymous", mapperFile = null, removeComments = true, placeholders = {}, customProps = [] } = options;
 	if (typeof options !== "object" || options === null) {
 		runtimeError([`{line}<$red:Invalid Options:$> <$yellow:The options argument must be a non-null object.$>{line}`]);
 	}
-	const knownProps = ["src", "format", "filename", "mapperFile", "removeComments", "placeholder", "placeholders", "customProps"];
+	const knownProps = ["src", "format", "filename", "mapperFile", "removeComments", "placeholders", "customProps"];
 	Object.keys(options).forEach(key => {
 		if (!knownProps.includes(key)) {
 			runtimeError([
@@ -299,7 +287,7 @@ async function transpile(options = {}) {
 		runtimeError([`{line}<$red:Missing Source:$> <$yellow:The 'src' argument is required for transpilation.$>{line}`]);
 	}
 
-	const sm = new SomMark({ src, format, filename, mapperFile, removeComments, placeholder, placeholders, customProps });
+	const sm = new SomMark({ src, format, filename, mapperFile, removeComments, placeholders, customProps });
 	return await sm.transpile();
 }
 
@@ -319,8 +307,8 @@ const lexSync = src => lexer(src);
  * @returns {Array<Object>} - The code tree.
  */
 const parseSync = (src, options = {}) => {
-	const { format = htmlFormat, filename = "anonymous", mapperFile = null, removeComments = true, placeholder = {}, placeholders = {}, customProps = [] } = options;
-	return new SomMark({ src, format, filename, mapperFile, removeComments, placeholder, placeholders, customProps }).parseSync();
+	const { format = htmlFormat, filename = "anonymous", mapperFile = null, removeComments = true, placeholders = {}, customProps = [] } = options;
+	return new SomMark({ src, format, filename, mapperFile, removeComments, placeholders, customProps }).parseSync();
 };
 
 import { findAndLoadConfig } from "./core/helpers/config-loader.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sommark",
-	"version": "4.0.0",
+	"version": "4.0.2",
 	"description": "SomMark is a declarative, extensible markup language for structured content that can be converted to HTML, Markdown, MDX, JSON, XML, and more.",
 	"main": "index.js",
 	"files": [