@schukai/monster 4.92.0 → 4.93.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 
 
+## [4.93.0] - 2026-01-13
+
+### Add Features
+
+- Enhance formatter with recursion detection and cycle handling
+
+
+
 ## [4.92.0] - 2026-01-12
 
 ### Add Features

package/package.json

@@ -1 +1 @@
-{"author":"Volker Schukai","dependencies":{"@floating-ui/dom":"^1.7.4","@popperjs/core":"^2.11.8"},"description":"Monster is a simple library for creating fast, robust and lightweight websites.","homepage":"https://monsterjs.org/","keywords":["framework","web","dom","css","sass","mobile-first","app","front-end","templates","schukai","core","shopcloud","alvine","monster","buildmap","stack","observer","observable","uuid","node","nodelist","css-in-js","logger","log","theme"],"license":"AGPL 3.0","main":"source/monster.mjs","module":"source/monster.mjs","name":"@schukai/monster","repository":{"type":"git","url":"https://gitlab.schukai.com/oss/libraries/javascript/monster.git"},"type":"module","version":"4.92.0"}
+{"author":"Volker Schukai","dependencies":{"@floating-ui/dom":"^1.7.4","@popperjs/core":"^2.11.8"},"description":"Monster is a simple library for creating fast, robust and lightweight websites.","homepage":"https://monsterjs.org/","keywords":["framework","web","dom","css","sass","mobile-first","app","front-end","templates","schukai","core","shopcloud","alvine","monster","buildmap","stack","observer","observable","uuid","node","nodelist","css-in-js","logger","log","theme"],"license":"AGPL 3.0","main":"source/monster.mjs","module":"source/monster.mjs","name":"@schukai/monster","repository":{"type":"git","url":"https://gitlab.schukai.com/oss/libraries/javascript/monster.git"},"type":"module","version":"4.93.0"}

package/source/text/formatter.mjs

@@ -34,6 +34,12 @@ const internalObjectSymbol = Symbol("internalObject");
  */
 const watchdogSymbol = Symbol("watchdog");
 
+/**
+ * @private
+ * @type {symbol}
+ */
+const recursionStackSymbol = Symbol("recursionStack");
+
 /**
  * @private
  * @type {symbol}
@@ -145,6 +151,10 @@ class Formatter extends BaseWithOptions {
 				open: ["${"],
 				close: ["}"],
 			},
+			recursion: {
+				maxDepth: 20,
+				detectCycles: true,
+			},
 			parameter: {
 				delimiter: "::",
 				assignment: "=",
@@ -226,6 +236,7 @@ class Formatter extends BaseWithOptions {
 		this[markerOpenIndexSymbol] = 0;
 		this[markerCloseIndexSymbol] = 0;
 		this[workingDataSymbol] = {};
+		this[recursionStackSymbol] = [];
 		return format.call(this, text);
 	}
 }
@@ -236,7 +247,14 @@ class Formatter extends BaseWithOptions {
  */
 function format(text) {
 	this[watchdogSymbol]++;
-	if (this[watchdogSymbol] > 20) {
+	const recursionOptions = this[internalSymbol]["recursion"] || {};
+	const maxDepth =
+		typeof recursionOptions.maxDepth === "number"
+			? recursionOptions.maxDepth
+			: 20;
+	const detectCycles = recursionOptions.detectCycles !== false;
+
+	if (this[watchdogSymbol] > maxDepth) {
 		throw new Error("too deep nesting");
 	}
 
@@ -252,13 +270,22 @@ function format(text) {
 		return text;
 	}
 
-	let result = tokenize.call(
+	const { text: tokenizedText, keys } = tokenize.call(
 		this,
 		validateString(text),
 		openMarker,
 		closeMarker,
+		detectCycles,
 	);
 
+	let pushedKeys = 0;
+	if (detectCycles && keys.length > 0) {
+		for (const key of keys) {
+			this[recursionStackSymbol].push(key);
+		}
+		pushedKeys = keys.length;
+	}
+
 	if (
 		this[internalSymbol]["marker"]["open"]?.[this[markerOpenIndexSymbol] + 1]
 	) {
@@ -271,7 +298,14 @@ function format(text) {
 		this[markerCloseIndexSymbol]++;
 	}
 
-	result = format.call(this, result);
+	let result;
+	try {
+		result = format.call(this, tokenizedText);
+	} finally {
+		if (pushedKeys > 0) {
+			this[recursionStackSymbol].splice(-pushedKeys);
+		}
+	}
 
 	return result;
 }
@@ -286,12 +320,14 @@ function format(text) {
  * @param {string} closeMarker
  * @return {string}
  */
-function tokenize(text, openMarker, closeMarker) {
+function tokenize(text, openMarker, closeMarker, detectCycles) {
 	const formatted = [];
+	const keys = [];
 
 	const parameterAssignment = this[internalSymbol]["parameter"]["assignment"];
 	const parameterDelimiter = this[internalSymbol]["parameter"]["delimiter"];
 	const callbacks = this[internalSymbol]["callbacks"];
+	const activeKeys = this[recursionStackSymbol] || [];
 
 	while (true) {
 		const startIndex = text.indexOf(openMarker);
@@ -317,8 +353,16 @@ function tokenize(text, openMarker, closeMarker) {
 					text.substring(insideStartIndex),
 					openMarker,
 					closeMarker,
+					detectCycles,
 				);
-				text = text.substring(0, insideStartIndex) + result;
+				text = text.substring(0, insideStartIndex) + result.text;
+				if (detectCycles && result.keys?.length) {
+					for (const key of result.keys) {
+						if (!keys.includes(key)) {
+							keys.push(key);
+						}
+					}
+				}
 				endIndex = text.substring(openMarker.length).indexOf(closeMarker);
 				if (endIndex !== -1) endIndex += openMarker.length;
 			}
@@ -331,6 +375,16 @@ function tokenize(text, openMarker, closeMarker) {
 		const key = text.substring(openMarker.length, endIndex);
 		const parts = key.split(parameterDelimiter);
 		const currentPipe = parts.shift();
+		const recursionKey = getRecursionKey(currentPipe);
+
+		if (detectCycles && recursionKey) {
+			if (activeKeys.includes(recursionKey)) {
+				throw new Error("cycle detected in formatter");
+			}
+			if (!keys.includes(recursionKey)) {
+				keys.push(recursionKey);
+			}
+		}
 
 		this[workingDataSymbol] = extend(
 			{},
@@ -372,5 +426,20 @@ function tokenize(text, openMarker, closeMarker) {
 		text = text.substring(endIndex + closeMarker.length);
 	}
 
-	return formatted.join("");
+	return { text: formatted.join(""), keys };
+}
+
+/**
+ * @private
+ * @param {string} pipe
+ * @return {string|null}
+ */
+function getRecursionKey(pipe) {
+	if (!pipe) return null;
+	const rawKey = pipe.split("|").shift().trim();
+	if (rawKey === "") return null;
+	if (rawKey.indexOf("path:") === 0) return rawKey.substring("path:".length);
+	if (rawKey.indexOf("static:") === 0)
+		return rawKey.substring("static:".length);
+	return rawKey;
 }

package/test/cases/text/formatter.mjs

@@ -288,7 +288,11 @@ describe('Formatter', function () {
                 mykey: '${mykey}',
             };
 
-            const formatter = new Formatter(inputObj);
+            const formatter = new Formatter(inputObj, {
+                recursion: {
+                    detectCycles: false,
+                },
+            });
 
             const text = '${mykey}';
             let formattedText = text;
@@ -300,8 +304,28 @@ describe('Formatter', function () {
 
             expect(() => formatter.format(formattedText)).to.throw('too deep nesting');
         });
+
+        it('should detect recursion cycles by default', () => {
+            const formatter = new Formatter({
+                a: '${b}',
+                b: '${a}',
+            });
+
+            expect(() => formatter.format('${a}')).to.throw('cycle detected in formatter');
+        });
+
+        it('should allow configuring max depth', () => {
+            const formatter = new Formatter({value: '${value}'}, {
+                recursion: {
+                    maxDepth: 3,
+                    detectCycles: false,
+                },
+            });
+
+            expect(() => formatter.format('${value}')).to.throw('too deep nesting');
+        });
         
     });
 
 
-});
+});