sommark 3.3.3 → 4.0.0

package/core/helpers/config-loader.js

@@ -1,48 +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 = startDir;
-	while (currentDir !== path.parse(currentDir).root) {
-		const configPath = path.join(currentDir, CONFIG_FILE_NAME);
-		try {
-			await fs.access(configPath);
-			return configPath;
-		} catch {
-			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;
@@ -52,48 +24,57 @@ 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) {
-	const startDir = targetPath ? (await fs.stat(targetPath)).isDirectory() ? targetPath : path.dirname(targetPath) : 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);
+	let startDir = process.cwd();
+	let configPath = null;
+
+	// 1. Check if targetPath is an explicit config file path
+	if (targetPath) {
 		try {
-			await fs.access(localConfigPath);
-			configPath = localConfigPath;
+			const stats = await fs.stat(targetPath);
+			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: []
+		removeComments: true,
 	};
 
 	if (configPath) {
 		const loadedConfig = await loadConfigFile(configPath);
 		if (loadedConfig) {
-			return { ...defaultConfig, ...loadedConfig, resolvedConfigPath: configPath };
+			const finalConfig = { ...defaultConfig, ...loadedConfig, resolvedConfigPath: configPath };
+			if (loadedConfig.outputDir) {
+				const configDir = path.dirname(configPath);
+				finalConfig.outputDir = path.resolve(configDir, loadedConfig.outputDir);
+			}
+			return finalConfig;
 		}
 	}
 

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";