sommark 4.1.0 → 4.2.0

package/core/helpers/config-loader.js

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 import fs from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 
@@ -40,7 +40,7 @@ export async function findAndLoadConfig(targetPath) {
 		try {
 			const absoluteTarget = path.resolve(cwd, targetPath);
 			const stats = await fs.stat(absoluteTarget);
-			
+
 			// If target is a .js file, it might be an explicit config (legacy/internal support)
 			if (stats.isFile() && absoluteTarget.endsWith(".js") && !absoluteTarget.endsWith("smark.config.js")) {
 				configPath = absoluteTarget;
@@ -74,7 +74,7 @@ export async function findAndLoadConfig(targetPath) {
 			// No config found in CWD
 		}
 	}
-	
+
 	const defaultConfig = {
 		outputFile: "output",
 		outputDir: startDir,
@@ -97,12 +97,12 @@ export async function findAndLoadConfig(targetPath) {
 		if (loadedConfig) {
 			// Support both mapperFile and mappingFile (backwards compatibility)
 			const finalMapper = loadedConfig.mapperFile || loadedConfig.mappingFile || defaultConfig.mapperFile;
-			
-			const finalConfig = { 
-				...defaultConfig, 
-				...loadedConfig, 
+
+			const finalConfig = {
+				...defaultConfig,
+				...loadedConfig,
 				mapperFile: finalMapper,
-				resolvedConfigPath: configPath 
+				resolvedConfigPath: configPath
 			};
 			if (loadedConfig.outputDir) {
 				const configDir = path.dirname(configPath);

package/core/helpers/lib.js

@@ -18,10 +18,7 @@ export function registerHostSettings(settings) {
     hostSettings = settings || {};
 }
 
-const manualVersion = "4.1.0";
-const version = await import(new URL("../../package.json", import.meta.url), { with: { type: "json" } })
-    .then(pkg => pkg.default.version || manualVersion)
-    .catch(() => manualVersion);
+const version = "4.2.0";
 
 const SomMark = {
     version,

package/core/helpers/preprocessor.js

@@ -1,9 +1,24 @@
-import path from "node:path";
-import fs from "node:fs";
+import path from "pathe";
 import * as acorn from "acorn";
 import evaluator from "../evaluator.js";
 import { transpilerError } from "../errors.js";
 
+let _nodeFsCache;
+async function getNodeFs() {
+	if (_nodeFsCache !== undefined) return _nodeFsCache;
+	try {
+		const m = await import("node:fs");
+		const raw = m.default || m;
+		_nodeFsCache = {
+			exists: (p) => raw.promises.access(p).then(() => true).catch(() => false),
+			readFile: (p, enc) => raw.promises.readFile(p, enc),
+		};
+	} catch {
+		_nodeFsCache = null;
+	}
+	return _nodeFsCache;
+}
+
 /**
  * Preprocesses a runtime JS block, parsing it with Acorn to locate
  * SomMark.static("...") and SomMark.import("...") calls, evaluating/loading them,
@@ -14,7 +29,7 @@ import { transpilerError } from "../errors.js";
  * @param {Object} security - Security restrictions from the engine configuration.
  * @returns {Promise<string>} - The preprocessed code.
  */
-export async function preprocessRuntimeLogic(code, filename = null, security = {}) {
+export async function preprocessRuntimeLogic(code, filename = null, security = {}, instance = null) {
 	let ast;
 	try {
 		ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "module" });
@@ -121,14 +136,16 @@ export async function preprocessRuntimeLogic(code, filename = null, security = {
 				}
 
 				// Resolve the file path relative to the template's base directory
-				let baseDir = process.cwd();
+				let baseDir = instance?.cwd || "/";
 				if (filename && filename !== "anonymous") {
 					baseDir = path.dirname(path.resolve(filename));
 				}
 				const resolvedPath = path.resolve(baseDir, argValue);
 
+				const fsImpl = instance?.fs || await getNodeFs();
+
 				// File presence validation
-				if (!fs.existsSync(resolvedPath)) {
+				if (!fsImpl || !await fsImpl.exists(resolvedPath)) {
 					transpilerError([
 						`<$red:SomMark.import File Error:$> File not found: <$magenta:${argValue}$>{line}`,
 						`<$yellow:Resolved Path:$> <$blue:${resolvedPath}$>{line}`
@@ -145,7 +162,7 @@ export async function preprocessRuntimeLogic(code, filename = null, security = {
 				}
 
 				let serialized = "";
-				const content = fs.readFileSync(resolvedPath, "utf-8");
+				const content = await fsImpl.readFile(resolvedPath, "utf-8");
 
 				if (ext === ".json") {
 					// Validate JSON structure

package/core/helpers/url.js

@@ -0,0 +1,12 @@
+export function fileURLToPath(url) {
+	if (typeof url !== "string") return url;
+	if (url.startsWith("file://")) {
+		let p = url.slice(7);
+		// On Windows (starts with /C:/ or similar), remove the leading slash:
+		if (/^\/[a-zA-Z]:/.test(p)) {
+			p = p.slice(1);
+		}
+		return p;
+	}
+	return url;
+}

package/core/modules.js

@@ -1,6 +1,5 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import path from "pathe";
+import { fileURLToPath } from "./helpers/url.js";
 import { runtimeError } from "./errors.js";
 import { IMPORT, USE_MODULE, TEXT, BLOCK, COMMENT, SLOT } from "./labels.js";
 
@@ -8,6 +7,9 @@ import { IMPORT, USE_MODULE, TEXT, BLOCK, COMMENT, SLOT } from "./labels.js";
  * Resolves a module path relative to a base directory.
  */
 const resolveModulePath = (filePath, currentBaseDir) => {
+	if (/^https?:\/\//.test(currentBaseDir)) {
+		return new URL(filePath, currentBaseDir.endsWith("/") ? currentBaseDir : currentBaseDir + "/").href;
+	}
 	return path.resolve(currentBaseDir, filePath);
 };
 
@@ -18,13 +20,13 @@ const resolveModulePath = (filePath, currentBaseDir) => {
  * @param {Object} [aliases={}] - Custom path aliases for modules.
  * @returns {string} - The corrected absolute path.
  */
-const normalizePath = (filename, aliases = {}) => {
-	if (!filename || filename === "anonymous") return process.cwd();
+const normalizePath = (filename, aliases = {}, cwd = "/") => {
+	if (!filename || filename === "anonymous") return cwd;
 
 	// Handle Aliases (like @/components)
 	for (const [prefix, replacement] of Object.entries(aliases)) {
 		if (filename.startsWith(prefix)) {
-			const resolvedPath = path.resolve(process.cwd(), filename.replace(prefix, replacement));
+			const resolvedPath = path.resolve(cwd, filename.replace(prefix, replacement));
 			return resolvedPath;
 		}
 	}
@@ -37,7 +39,7 @@ const normalizePath = (filename, aliases = {}) => {
 		}
 	}
 
-	return path.resolve(process.cwd(), filename);
+	return path.resolve(cwd, filename);
 };
 
 const VAR_PATTERN = /SOMMARK_UNRESOLVED_v_(.+?)_SOMMARK/g;
@@ -135,7 +137,7 @@ export async function resolveModules(ast, context) {
 	const modules = new Map();
 	const filename = context.filename || "anonymous";
 	const importAliases = context.instance.importAliases || {};
-	const absFilename = normalizePath(filename, importAliases);
+	const absFilename = normalizePath(filename, importAliases, context.instance.cwd || "/");
 
 	// baseDir can be a local path
 	const baseDir = context.instance.baseDir || ((filename === "anonymous") ? absFilename : path.dirname(absFilename));
@@ -231,7 +233,7 @@ export async function resolveModules(ast, context) {
 				let resolvedPath = filePath;
 				for (const [prefix, replacement] of Object.entries(importAliases)) {
 					if (filePath.startsWith(prefix)) {
-						resolvedPath = path.resolve(process.cwd(), filePath.replace(prefix, replacement));
+						resolvedPath = path.resolve(context.instance.cwd || "/", filePath.replace(prefix, replacement));
 						break;
 					}
 				}
@@ -241,11 +243,11 @@ export async function resolveModules(ast, context) {
 
 				// Local Path Resolution with Auto-Extension
 				let localPath = absolutePath;
-				if (!fs.existsSync(localPath) && !localPath.endsWith(".smark")) {
+				if (!await context.instance.fs.exists(localPath) && !localPath.endsWith(".smark")) {
 					const withSmark = localPath + ".smark";
-					if (fs.existsSync(withSmark)) localPath = withSmark;
+					if (await context.instance.fs.exists(withSmark)) localPath = withSmark;
 				}
-				if (!fs.existsSync(localPath)) {
+				if (!await context.instance.fs.exists(localPath)) {
 					runtimeError([`<$red:Module Path Error:$> File not found: <$magenta:${filePath}$> at line <$yellow:${node.range.start.line + 1}$>`]);
 				}
 				let mod = { path: absolutePath, localPath: localPath, type: "smark" };
@@ -289,7 +291,7 @@ export async function resolveModules(ast, context) {
 				if (cached) {
 					expandedNodes = trimAst(cloneAst(cached));
 				} else {
-					const content = fs.readFileSync(mod.localPath, "utf-8");
+					const content = await context.instance.fs.readFile(mod.localPath, "utf-8");
 					const SomMark = context.instance.constructor;
 					const subSmark = new SomMark({
 						src: content,
@@ -347,7 +349,7 @@ export async function resolveModules(ast, context) {
 				if (cached) {
 					subAst = cloneAst(cached);
 				} else {
-					const content = fs.readFileSync(mod.localPath, "utf-8");
+					const content = await context.instance.fs.readFile(mod.localPath, "utf-8");
 					const SomMark = context.instance.constructor;
 					const subSmark = new SomMark({
 						src: content,

package/core/transpiler.js

@@ -1,4 +1,3 @@
-import crypto from "node:crypto";
 import { BLOCK, TEXT, INLINE, ATBLOCK, COMMENT, COMMENT_BLOCK, STATIC_LOGIC, RUNTIME_LOGIC, FOR_EACH } from "./labels.js";
 import { transpilerError } from "./errors.js";
 import evaluator from "./evaluator.js";
@@ -7,13 +6,13 @@ import { dedentBy } from "../helpers/dedent.js";
 import { preprocessRuntimeLogic } from "./helpers/preprocessor.js";
 import { wrapRuntimeLogic } from "./helpers/runtimeOutput.js";
 
-/**
- * SomMark Transpiler
- * This engine converts the AST into its final text format (like HTML or Markdown)
- * using rules provided by a mapper.
- */
+const randomBytesHex = (size) => {
+	const arr = new Uint8Array(size);
+	globalThis.crypto.getRandomValues(arr);
+	return Array.from(arr).map(b => b.toString(16).padStart(2, "0")).join("");
+};
 
-const BODY_PLACEHOLDER = `SOMMARKBODYPLACEHOLDER${crypto.randomBytes(8).toString("hex")}SOMMARK`;
+const BODY_PLACEHOLDER = `SOMMARKBODYPLACEHOLDER${randomBytesHex(8)}SOMMARK`;
 
 /** 
  * Extracts all plain text from a node and its children.
@@ -46,7 +45,7 @@ function getNodeText(node) {
  * @param {Object} mapper_file - The rules for how to convert each node.
  * @returns {Promise<string>} - The final text for this node.
  */
-async function generateOutput(ast, i, format, mapper_file, security = {}, parentId = null, generateRuntimeOutput = false, hideRuntimeOutput = false) {
+async function generateOutput(ast, i, format, mapper_file, security = {}, parentId = null, generateRuntimeOutput = false, hideRuntimeOutput = false, instance = null) {
 	const node = Array.isArray(ast) ? ast[i] : ast;
 	if (!node) return "";
 
@@ -61,7 +60,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 		if (node.body) {
 			evaluator.pushScope();
 			for (let j = 0; j < node.body.length; j++) {
-				bodyOutput += await generateOutput(node.body, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput);
+				bodyOutput += await generateOutput(node.body, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 			}
 			await evaluator.popScope();
 		}
@@ -86,7 +85,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 	}
 
 	if (node.type === RUNTIME_LOGIC) {
-		const preprocessed = await preprocessRuntimeLogic(node.code, mapper_file?.options?.filename, security);
+		const preprocessed = await preprocessRuntimeLogic(node.code, mapper_file?.options?.filename, security, instance);
 		if (hideRuntimeOutput) {
 			return "";
 		}
@@ -169,7 +168,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 			});
 
 			for (let j = 0; j < cleanedBody.length; j++) {
-				output += await generateOutput(cleanedBody, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput);
+				output += await generateOutput(cleanedBody, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 			}
 
 			await evaluator.popScope();
@@ -192,7 +191,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 
 		const hasRuntime = node.body?.some(child => child.type === RUNTIME_LOGIC);
 		if (hasRuntime) {
-			secretId = `sommark-${node.id.toLowerCase()}-${crypto.randomBytes(4).toString("hex")}`;
+			secretId = `sommark-${node.id.toLowerCase()}-${randomBytesHex(4)}`;
 		}
 	}
 
@@ -248,7 +247,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 			let resolvedBody = "";
 			evaluator.pushScope();
 			for (let j = 0; j < node.body.length; j++) {
-				resolvedBody += await generateOutput(node.body, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput);
+				resolvedBody += await generateOutput(node.body, j, format, mapper_file, security, parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 			}
 			await evaluator.popScope();
 			content = dedentBy(resolvedBody, node.range?.start?.character || 0);
@@ -258,7 +257,7 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 			let childrenOutput = "";
 			if (node.body) {
 				for (let j = 0; j < node.body.length; j++) {
-					childrenOutput += await generateOutput(node.body, j, format, mapper_file, security, secretId || parentId, generateRuntimeOutput, hideRuntimeOutput);
+					childrenOutput += await generateOutput(node.body, j, format, mapper_file, security, secretId || parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 				}
 			}
 			return childrenOutput;
@@ -306,8 +305,8 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 				switch (body_node.type) {
 					case TEXT:
 						const text = String(body_node.text || "");
-						// Dedent text relative to the parent block's indentation
-						const localDedentedText = dedentBy(text, node.range?.start?.character || 0);
+						// Only dedent multi-line text — inline spaces (no newlines) are separators, not indentation
+						const localDedentedText = text.includes("\n") ? dedentBy(text, node.range?.start?.character || 0) : text;
 						let bodyTextVal = mapper_file ? mapper_file.text(localDedentedText, { ...target?.options, escape: parentEscape }) : localDedentedText;
 						if (parentEscape === false && security?.sanitize && typeof security.sanitize === "function") {
 							bodyTextVal = security.sanitize(bodyTextVal);
@@ -370,11 +369,11 @@ async function generateOutput(ast, i, format, mapper_file, security = {}, parent
 
 					case FOR_EACH:
 					case BLOCK:
-						bodyOutput = await generateOutput(body_node, 0, format, mapper_file, security, secretId || parentId, generateRuntimeOutput, hideRuntimeOutput);
+						bodyOutput = await generateOutput(body_node, 0, format, mapper_file, security, secretId || parentId, generateRuntimeOutput, hideRuntimeOutput, instance);
 						break;
 
 					case RUNTIME_LOGIC:
-						const preprocessedBody = await preprocessRuntimeLogic(body_node.code, mapper_file?.options?.filename, security);
+						const preprocessedBody = await preprocessRuntimeLogic(body_node.code, mapper_file?.options?.filename, security, instance);
 						if (hideRuntimeOutput) {
 							bodyOutput = "";
 						} else {
@@ -483,6 +482,11 @@ export async function transpiler(optionsOrAst, format, mapperFile) {
 	if (!body || !Array.isArray(body)) return "";
 
 	const settings = optionsOrAst?.settings || { format: targetFormat || "html" };
+	const instance = optionsOrAst?.instance;
+	if (instance) {
+		settings.instance = instance;
+		settings.fs = instance.fs;
+	}
 
 	// Initialize Logic Sandbox
 	await evaluator.init(null, security, settings, targetMapper);
@@ -500,7 +504,7 @@ export async function transpiler(optionsOrAst, format, mapperFile) {
 	try {
 		for (let i = 0; i < body.length; i++) {
 			const node = body[i];
-			const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, generateRuntimeOutput, hideRuntimeOutput);
+			const blockOutput = await generateOutput(body, i, targetFormat, targetMapper, security, null, generateRuntimeOutput, hideRuntimeOutput, instance);
 
 			let finalBlockOutput = blockOutput;
 			if (prev_was_silent && node.type === TEXT) {

package/helpers/fetch-fs.js

@@ -0,0 +1,37 @@
+export class FetchFS {
+    constructor(baseURL) {
+        this.baseURL = baseURL.endsWith("/") ? baseURL : baseURL + "/";
+        this._cache = new Map();
+    }
+
+    _resolve(p) {
+        if (p.startsWith("http://") || p.startsWith("https://")) return p;
+        return this.baseURL + p.replace(/^\//, "");
+    }
+
+    async readFile(p, encoding) {
+        const url = this._resolve(p);
+        if (this._cache.has(url)) return this._cache.get(url);
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`File not found: ${p} (${res.status})`);
+        const text = await res.text();
+        this._cache.set(url, text);
+        return text;
+    }
+
+    async exists(p) {
+        try { await this.readFile(p); return true; }
+        catch { return false; }
+    }
+
+    // Sync versions — backed by cache, only valid after readFile has been called for that path
+    existsSync(p) {
+        return this._cache.has(this._resolve(p));
+    }
+
+    readFileSync(p, encoding) {
+        const cached = this._cache.get(this._resolve(p));
+        if (cached !== undefined) return cached;
+        throw new Error(`Not in cache: ${p}. Call readFile first.`);
+    }
+}

package/helpers/spinner.js

@@ -9,7 +9,11 @@ let originalStderrWrite = null;
 let redrawTimeout = null;
 
 export function startSpinner() {
-	if (process.stdout.isTTY && !activeSpinner) {
+	if (typeof process === "undefined" || !process.stdout?.isTTY) {
+		spinnerDepth++;
+		return;
+	}
+	if (!activeSpinner) {
 		// Hide terminal cursor for a clean premium visual feel
 		process.stdout.write("\x1b[?25l");
 
@@ -84,8 +88,10 @@ export function stopSpinner() {
 				originalStderrWrite = null;
 			}
 
+		if (typeof process !== "undefined" && process.stdout) {
 			// Clear the spinner line and restore the terminal cursor
 			process.stdout.write("\r\x1b[K\x1b[?25h");
 		}
+		}
 	}
 }

package/helpers/virtual-fs.js

@@ -0,0 +1,29 @@
+import path from "pathe";
+
+/**
+ * Avoids any dependency on Node.js built-in modules (like buffer, path, stream).
+ */
+export class VirtualFS {
+    constructor(files = {}) {
+        this.files = {};
+        for (const [key, value] of Object.entries(files)) {
+            this.files[path.normalize(key)] = value;
+        }
+    }
+
+    existsSync(p) {
+        const normalized = path.normalize(p);
+        return normalized in this.files;
+    }
+
+    readFileSync(p, encoding) {
+        const normalized = path.normalize(p);
+        if (normalized in this.files) {
+            return this.files[normalized];
+        }
+        throw new Error(`File not found: ${p}`);
+    }
+
+    async exists(p) { return this.existsSync(p); }
+    async readFile(p, encoding) { return this.readFileSync(p, encoding); }
+}

package/index.browser.js

@@ -0,0 +1,87 @@
+import SomMark, { setDefaultFs, setDefaultCwd } from "./index.shared.js";
+export * from "./index.shared.js";
+
+setDefaultFs(null);
+setDefaultCwd("/");
+
+/**
+ * Resolves a relative path into a full URL using the current document location.
+ * Use this to set `baseDir` when loading .smark modules via fetch in the browser.
+ *
+ * @param {string} relativePath - Path relative to the HTML document (e.g. "./templates/").
+ * @returns {string} Absolute URL string suitable for use as `baseDir`.
+ *
+ * @example
+ * import SomMark, { resolveBaseDir } from "sommark/browser";
+ * const engine = new SomMark({ src, format: "html", baseDir: resolveBaseDir("./templates/") });
+ */
+export function resolveBaseDir(relativePath = "./") {
+    if (typeof document === "undefined") {
+        throw new Error(
+            "[SomMark] resolveBaseDir() can only be called in a browser environment.\n" +
+            "In Node.js, pass a file path directly as 'baseDir' instead."
+        );
+    }
+
+    if (typeof relativePath !== "string" || relativePath.trim() === "") {
+        throw new Error(
+            "[SomMark] resolveBaseDir() expects a non-empty string path, " +
+            `but received: ${JSON.stringify(relativePath)}`
+        );
+    }
+
+    try {
+        return new URL(relativePath, document.baseURI).href;
+    } catch (err) {
+        throw new Error(
+            `[SomMark] resolveBaseDir() could not resolve path '${relativePath}' ` +
+            `against document URL '${document.baseURI}'.\n${err.message}`
+        );
+    }
+}
+
+/**
+ * Injects compiled HTML into a container and activates any <script> tags inside it.
+ * Browsers intentionally skip scripts inserted via innerHTML — this re-creates each
+ * one as a live DOM element so they execute normally.
+ *
+ * @param {HTMLElement} container - The element to render into.
+ * @param {string} html - The compiled HTML string.
+ *
+ * @example
+ * import SomMark, { renderCompiledHTML } from "sommark/browser";
+ * const html = await new SomMark({ src, format: "html" }).transpile();
+ * renderCompiledHTML(document.getElementById("output"), html);
+ */
+export function renderCompiledHTML(container, html) {
+    if (typeof document === "undefined") {
+        throw new Error(
+            "[SomMark] renderCompiledHTML() can only be called in a browser environment."
+        );
+    }
+    if (!(container instanceof HTMLElement)) {
+        throw new TypeError(
+            "[SomMark] renderCompiledHTML() expects an HTMLElement as the first argument, " +
+            `but received: ${Object.prototype.toString.call(container)}`
+        );
+    }
+    if (typeof html !== "string") {
+        throw new TypeError(
+            "[SomMark] renderCompiledHTML() expects a string as the second argument, " +
+            `but received: ${Object.prototype.toString.call(html)}`
+        );
+    }
+
+    container.innerHTML = html;
+
+    for (const inertScript of container.querySelectorAll("script")) {
+        const liveScript = document.createElement("script");
+        for (const { name, value } of inertScript.attributes) {
+            liveScript.setAttribute(name, value);
+        }
+        liveScript.textContent = inertScript.textContent;
+        inertScript.replaceWith(liveScript);
+    }
+}
+
+export default SomMark;