sommark 3.3.4 → 4.0.1

package/core/helpers/config-loader.js

@@ -1,51 +1,20 @@
 import path from "node:path";
-import os from "node:os";
 import fs from "node:fs/promises";
-import { pathToFileURL, fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
 
 const CONFIG_FILE_NAME = "smark.config.js";
 
 /**
- * Gets the global configuration directory based on the OS.
- */
-export function getConfigDir() {
-	const homeDir = os.homedir();
-	if (process.platform === "win32") {
-		return path.join(process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"), "sommark");
-	} else if (process.platform === "darwin") {
-		return path.join(homeDir, "Library", "Application Support", "sommark");
-	} else {
-		return path.join(process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config"), "sommark");
-	}
-}
-
-/**
- * Recursively searches for smark.config.js up the directory tree starting from startDir.
- */
-async function findConfig(startDir) {
-	let currentDir = path.resolve(startDir);
-	const root = path.parse(currentDir).root;
-
-	while (true) {
-		const configPath = path.join(currentDir, CONFIG_FILE_NAME);
-		try {
-			await fs.access(configPath);
-			return configPath;
-		} catch {
-			if (currentDir === root) break;
-			currentDir = path.dirname(currentDir);
-		}
-	}
-	return null;
-}
-
-/**
- * Loads the configuration from a file.
+ * Loads a configuration object from a Javascript file.
+ * We add the current time to the file path. This makes Node.js read 
+ * the file again instead of using an old copy from its memory.
+ * 
+ * @param {string} configPath - The absolute path to the config file.
+ * @returns {Promise<Object|null>} - The configuration object or null on error.
  */
 async function loadConfigFile(configPath) {
 	if (!configPath) return null;
 	try {
-		// Use a timestamp to bypass cache for dynamic updates in LSP
 		const configURL = `${pathToFileURL(configPath).href}?t=${Date.now()}`;
 		const loadedModule = await import(configURL);
 		return loadedModule.default || loadedModule;
@@ -55,73 +24,69 @@ async function loadConfigFile(configPath) {
 }
 
 /**
- * Finds and loads the configuration starting from targetPath.
- * Checks local directory, parent directories, and finally the global config directory.
+ * Finds and loads the SomMark configuration file.
+ * It looks in the current folder or a specific path if provided.
+ * 
+ * @param {string|null} targetPath - A specific file or folder to look in.
+ * @returns {Promise<Object>} - The final configuration merged with defaults.
  */
 export async function findAndLoadConfig(targetPath) {
-	let startDir;
+	let startDir = process.cwd();
+	let configPath = null;
+
+	// 1. Check if targetPath is an explicit config file path
 	if (targetPath) {
 		try {
 			const stats = await fs.stat(targetPath);
-			startDir = stats.isDirectory() ? targetPath : path.dirname(targetPath);
-		} catch {
-			startDir = process.cwd();
-		}
-	} else {
-		startDir = process.cwd();
-	}
-	
-	let configPath = await findConfig(startDir);
-	
-	if (!configPath) {
-		// As a fallback, check the current working directory of the process
-		// This helps LSP find the project config when running in the project root
-		const localConfigPath = path.join(process.cwd(), CONFIG_FILE_NAME);
-		try {
-			await fs.access(localConfigPath);
-			configPath = localConfigPath;
+			if (stats.isFile() && targetPath.endsWith(".js")) {
+				configPath = path.resolve(targetPath);
+			} else {
+				startDir = stats.isDirectory() ? targetPath : path.dirname(targetPath);
+			}
 		} catch {
-			// Not in CWD
+			// Path doesn't exist
 		}
 	}
 
+	// 2. Check the current folder
 	if (!configPath) {
-		const globalConfigPath = path.join(getConfigDir(), CONFIG_FILE_NAME);
+		const localConfig = path.join(startDir, CONFIG_FILE_NAME);
 		try {
-			await fs.access(globalConfigPath);
-			configPath = globalConfigPath;
+			await fs.access(localConfig);
+			configPath = localConfig;
 		} catch {
-			// No config found
+			// No local config found
 		}
 	}
-
+	
 	const defaultConfig = {
 		outputFile: "output",
 		outputDir: startDir,
-		mappingFile: null,
-		plugins: [],
-		priority: [],
-		excludePlugins: [],
-		includeDocument: true
+		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;
 			
-			// Ensure outputDir is resolved if it's relative in the config
+			const finalConfig = { 
+				...defaultConfig, 
+				...loadedConfig, 
+				mapperFile: finalMapper,
+				resolvedConfigPath: configPath 
+			};
 			if (loadedConfig.outputDir) {
 				const configDir = path.dirname(configPath);
 				finalConfig.outputDir = path.resolve(configDir, loadedConfig.outputDir);
 			}
-
 			return finalConfig;
 		}
 	}
 
 	return { ...defaultConfig, resolvedConfigPath: null };
 }
-
-
-

package/core/labels.js

@@ -1,27 +1,39 @@
+/**
+ * These labels identify different parts of the code (like blocks or text) 
+ * so the system knows how to handle them.
+ */
 export const BLOCK = "Block",
 	TEXT = "Text",
 	INLINE = "Inline",
 	ATBLOCK = "AtBlock",
 	COMMENT = "Comment",
 	IMPORT = "Import",
-	USE_MODULE = "$use-module",
-	SEMICOLON = "Semicolon",
+	USE_MODULE = "$use-module";
+
+/**
+ * Names for symbols used to separate parts of the code (like commas and colons).
+ */
+export const SEMICOLON = "Semicolon",
 	BLOCKCOMMA = "Block-comma",
 	ATBLOCKCOMMA = "Atblock-comma",
 	INLINECOMMA = "Inline-comma",
 	BLOCKCOLON = "Block-colon",
 	ATBLOCKCOLON = "Atblock-colon",
-	INLINECOLON = "Inline-colon",
-	block_id = "Block Identifier",
+	INLINECOLON = "Inline-colon";
+
+/**
+ * These names are used in error messages to tell you exactly which part 
+ * of your code has a mistake.
+ */
+export const block_id = "Block Identifier",
 	block_value = "Block Value",
-	block_id_2 = "Block Identifier 2",
+	block_key = "Block Key",
 	block_end = "Block end",
 	inline_id = "Inline Identifier",
-	inline_value = "Inline Value",
-	inline_id_2 = "Inline Identifier 2",
+	inline_text = "Inline Text",
 	at_id = "At Identifier",
 	at_value = "At Value",
-	at_id_2 = "At Identifier 2",
+	atblock_key = "AtBlock Key",
 	at_end = "Atblock End",
-	block_end_2 = "Block End 2",
+	/** Reserved keyword for closing blocks */
 	end_keyword = "end";