cavalion-js 1.0.84 → 1.0.85

package/CHANGELOG.md

@@ -1,3 +1,53 @@
+### `2026/03/16` 1.0.85 Formatting and entity expansion updates
+
+**console/node/vcl/Component.js**:
+
+* Adds root-component console rendering with `uri#hashCode`
+* Keeps non-root `Component` labels unchanged; still shows `:root` and `:selected` markers.
+* **Breaking**: code using `expand.Entity(...)` must migrate to `expand.newEntity(...)`.
+
+**entities/expand.js**:
+
+* Renames `expand.Entity` to `expand.newEntity` in 
+* Adds `expand.DefaultEntity` for generic alias-based `join()` and `expand()` behavior.
+* Improves `expand.attributes4()` fallback handling for unknown entity relations and single-item tuple paths.
+* Extends `prefixId()` to preserve `count:id` selectors without prepending `id,`.
+
+**js/_js.js**:
+
+* Adds `js.qq(a, b)` for nullish fallback values.
+* Fixes `String.format()` width and padding behavior for `%d`, including negative zero-padded numbers.
+* Fixes `String.format()` float formatting for `%f`, including width, precision, and negative values.
+* Fixes string alignment in `String.format()` for `%s`/`%H`/`%n`; left/right padding now behaves consistently.
+* Improves `%` specifier parsing to stop safely at end-of-format input.
+* Adjusts numeric formatting to return the original positive value when fixed `"0000"` formatting collapses to `"0"`.
+
+**locale.js**:
+
+* Adds `locale.prefixed(...).prefixed(...)` chaining in `src/locale.js`.
+* Fixes prefixed locale fallback output so missing keys do not duplicate the prefix.
+
+
+### `2026/02/05` Introducing entities.expand
+
+It turns `expand.js` from a small “string builder” helper into a mini expansion/join framework.
+
+* **Before:** the module essentially returned a function that, given an attribute (or list of attributes) plus a `path`, produced strings like `path.attr`, with some support for comma lists, aliases (`"id foo"`), and typed prefixes (`"Type:attr"`). Arrays were turned into a **comma-joined string**.
+
+* **Now:** it exports a reusable `expand(expanderFn, as, path)` function plus an **`Entity` factory** (`expand.Entity(...)`) that builds an object representing an entity with:
+
+  * **Named expanders** generated from a `paths` map (so you can call `Entity.bedrijf("id")` and get `meetpunt.onderzoek.bedrijf.id`).
+  * A **`join(alias, attributes)`** method that resolves a join alias (case-insensitive) to one of those expanders via a mapping; unknown aliases now **throw an error**.
+  * An **`expand(...)`** convenience method that expands multiple attributes using `expand.attributes4(...)`.
+
+* **Normalization changes:**
+
+  * Comma-separated strings are split and **trimmed**.
+  * If `as` is an array, it maps each item through the expander and returns an **array** (not a comma-joined string).
+  * There’s a helper that **auto-prefixes `"id"`** (e.g., ensures `"id"` is included in expansions) and supports mixed input shapes (strings and `[expanderName, attrs]` tuples).
+
+Overall, it standardizes how “expand fields” and “join expansions” are defined and executed, moving from ad-hoc string concatenation to an entity-centric API with explicit alias resolution and stricter error handling.
+
 ### `2026/01/18` - 1.0.84
 
 EM now uses the browser’s fetch API instead of jQuery. 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cavalion-js",
-  "version": "1.0.84",
+  "version": "1.0.85",
   "description": "Cavalion common JavaScript library",
   "main": "index.js",
   "scripts": {

package/src/console/node/vcl/Component.js

@@ -16,17 +16,25 @@ define(function(require) {
 				/** @overrides ../Node.prototype.initializeValue */
 				// node.innerHTML = String.format("%H<span class='uri'> - %H</span>",
 				// 		js.nameOf(this._value), this._value.getUri());
-				var root = this._value.isRootComponent() ? ":root" : "";
+				var isRoot = this._value.isRootComponent();
+				var root = isRoot ? ":root" : "";
 				var uri = this._value._uri;//this._value.isRootComponent() ? this._value._uri : this._value.getUri();
 				if(uri !== this._value.getUri()) {
 					uri = js.sf("%s - %s", uri, this._value.getUri());
 				}
-				
+
 				var selected = this._value.isSelected && this._value.isSelected() ? ":selected" : "";
-				node.innerHTML = String.format(
-						"%H<span class='uri'> - %H%H%H</span>",
-						js.nameOf(this._value), 
-						uri, root, selected);
+				if(isRoot) {
+					node.innerHTML = String.format(
+							"%H#%s<span class='uri'> - %H%H%H</span>",
+							uri, this._value.hashCode(), js.nameOf(this._value), 
+							root, selected);
+				} else {
+					node.innerHTML = String.format(
+							"%H<span class='uri'> - %H%H%H</span>",
+							js.nameOf(this._value), 
+							uri, root, selected);
+				}
 			}
 		},
 		statics: {

package/src/entities/expand.js

@@ -1,30 +1,146 @@
-define([], () => (fn, as, path) => {
-	if(as === undefined) {
-		return path;
-	}
-	if(typeof as === "string" && as.indexOf(",") !== -1) { 
-		as = as.split(","); 
-	}
+define(["js"], (js) => {
 
-	if(as instanceof Array) {
-		return as.map(fn).join(",");
-	} 
+// TODO join and expand => @join, @expand
 	
-	if(path) {
-		let alias = "";
+	const KEY_name = "@_name", KEY_expanders = "@_expanders";
+
+	function Entity(name) {
+		this[KEY_name] = name;
+		this[KEY_expanders] = {};
+	}
+	Entity.prototype.join = function(alias, attributes) {
+		const expanders = this[KEY_expanders];
+		const expander = expanders[alias] || expanders[alias.toLowerCase()];
 
-		as = as.split(" ");
-		if(as.length === 2) {
-			alias = " " + as.pop();
+		if(!expander) {
+			throw new Error("Unknown join alias/entity: " + alias);
 		}
-		as = as.pop();
 		
-		as = as.split(":");
-		if(as.length > 1) {
-			return js.sf("%s:%s.%s%s", as[0], path, as[1], alias);
+		return expander(attributes);
+	};
+	Entity.prototype.expand = function(...args) {
+		const arr = (args.length === 1 && Array.isArray(args[0])) ? args[0] : args;
+		return expand.attributes4(this, arr);
+	};
+
+	const isFn = (f) => typeof f === "function";
+	const makeFn = (path) => {
+		/**
+		 * makeFn(path) -> function(as) { ... }
+		 * Creates a self-recursive expander that calls expand(fn, as, path).
+		 */
+		function fn(as) {
+			return expand(fn, as, path);
+		}
+		return fn;
+	};
+	const prefixId = (s) => !s ? "id" : s.startsWith("id") || s.startsWith("count:id") ? s : "id," + s;
+
+	function expand(expander, as, path) {
+		/**
+		 * expand(expanderFn, as, path)
+		 *
+		 * - If as === undefined: returns path (so expanders can self-describe)
+		 * - If as is "a,b,c": treated as ["a","b","c"]
+		 * - If as is Array: maps each element through the same expander
+		 * - If as contains "attr alias": returns "path.attr alias"
+		 * - If as contains "type:attr": returns "type:path.attr"
+		 */
+		if(as === undefined) {
+			return path;
+		}
+		if(typeof as === "string" && as.indexOf(",") !== -1) {
+			as = as.split(",").map(function(s) { return s.trim(); });
+		}
+		if(Array.isArray(as)) {
+			return as.map(function(a) { return expander(a); });
+		}
+	
+		var attr = String(as);
+	
+		if(path) {
+			// typed prefix: "Watermonster:id" => "Watermonster:path.id"
+			if(attr.indexOf(":") !== -1) {
+				var t = attr.split(":");
+				return js.sf("%s:%s.%s", t[0], path, t[1]);
+			}
+
+			// aliasing: "id foo" => "path.id foo"
+			if(attr.indexOf(" ") !== -1) {
+				var parts = attr.split(" ");
+				return js.sf("%s.%s %s", path, parts[0], parts.slice(1).join(" "));
+			}
+	
+	
+			return js.sf("%s.%s", path, attr);
+		}
+	
+		// No path: just return the attribute as-is (e.g. root filter fields)
+		return attr;
+	}
+	expand.newEntity = function(name, paths, joinToExpander) {
+		/**
+		 * expand.entity(name, paths, joinToExpander)
+		 *
+		 * paths: { bedrijf: "meetpunt.onderzoek.bedrijf", ... }
+		 * joinToExpander: { Watermonster: "watermonsters", ... }
+		 *
+		 * Returns an object where each expander is available directly as a method:
+		 *	Entity.bedrijf("id") -> "meetpunt.onderzoek.bedrijf.id"
+		 *
+		 * Also provides:
+		 *	Entity.join("Bedrijf", "id") -> same, via joinToExpander / expanders lookup
+		 */
+		const entity = new Entity(name);
+
+		// Build expanders and attach them as direct methods (Entity.bedrijf(...))
+		for(const k in paths) {
+			if(paths.hasOwnProperty(k)) {
+				const fn = makeFn(paths[k] || undefined);
+				entity[KEY_expanders][k] = fn;
+				if(!entity[k]) entity[k] = fn;
+			}
+		}
+	
+		// Normalize join map keys to lower-case
+		for(const j in joinToExpander) {
+			if(joinToExpander.hasOwnProperty(j) && !entity[KEY_expanders][j]) {
+				entity[KEY_expanders][j] = entity[KEY_expanders][joinToExpander[j]];
+			}
+		}
+	
+		return entity;
+	};
+	expand.attributes4 = (entity, arr) => arr.map(a => {
+		if(a instanceof Array) {
+			if(!entity[a[0]]) { 
+				if(a.length === 1) {
+					return a[0] + ".id";
+				}
+				return prefixId(a[1]).split(",").map(s => a[0] + "." + s);
+			}
+			return entity[a[0]](prefixId(a[1]));
+		} else if(typeof a === "string") {
+			return prefixId(a).split(",");
+		}
+	}).flat();
+
+	function DefaultEntity(name) {
+		this[KEY_name] = name;
+		this.join = (alias, attributes) => {
+			return attributes.split(",").map(a => [alias, a].join("."));
+		},
+		this.expand = (...args) => {
+			return args.map(a => {
+				if(a instanceof Array) {
+					const arr = prefixId(a[1]).split(",");
+					return arr.map(path => [a[0], path].join("."));
+				} else if(typeof a === "string") {
+					return prefixId(a).split(",");
+				}
+			});
 		}
-		return js.sf("%s.%s%s", path, as, alias);
 	}
 
-	return as;
+	return js.mi(expand, { DefaultEntity });
 });

package/src/js/_js.js

@@ -49,6 +49,7 @@ define(function(require) {
 		sj: serialize.serialize, //JSON.stringify,
 		pj: serialize.deserialize, //JSON.parse,
 		sf: String.format,
+		qq: (a, b) => (a === null || a === undefined) ? b : a,
 		eval: global[tlc("EVAL")],
 		nameOf: nameOf,
 		defineClass: defineClass,

package/src/js/extensions.js

@@ -309,12 +309,12 @@ const stringify = (obj) => {
 		 */
 		var s = [];
 		var idx = -1, pos = 0;
-		var i = 1;
+		var argi = 1;
 		var specifiers = "cdfsHn";
-
+	
 		do {
 			idx = fmt.indexOf("%", ++idx);
-
+	
 			if(idx !== -1) {
 				if(fmt.charAt(idx + 1) === "%") {
 					s.push(fmt.substring(pos, idx));
@@ -323,29 +323,45 @@ const stringify = (obj) => {
 					pos = idx + 1;
 				} else {
 					s.push(fmt.substring(pos, idx));
-					var mod = "", ch = fmt.charAt(idx + 1);
-					while(specifiers.indexOf(ch) === -1) {
+	
+					var mod = "";
+					var ch = fmt.charAt(idx + 1);
+	
+					while(specifiers.indexOf(ch) === -1 && ch !== "") {
 						mod += ch;
 						idx++;
 						ch = fmt.charAt(idx + 1);
 					}
+	
 					if(ch === "c") {
 						if(mod === "*") {
-							var n = arguments[i++];
+							var n = arguments[argi++];
 							while(n--) {
-								s.push(arguments[i]);
+								s.push(arguments[argi]);
 							}
-							i++;
+							argi++;
 						} else {
-							s.push(arguments[i++]);
+							s.push(arguments[argi++]);
 						}
+	
 					} else if(ch === "d") {
-						var value = "" + parseInt(arguments[i++], 10);
+						var n = parseInt(arguments[argi++], 10);
+						var value = "" + n;
+	
 						if(mod.length) {
+							var len;
+	
 							if(mod.charAt(0) === "0") {
-								var len = parseInt(mod.substring(1), 10) || 0;
-								while(value.length < len) {
-									value = "0" + value;
+								len = parseInt(mod.substring(1), 10) || 0;
+	
+								if(value.charAt(0) === "-") {
+									while(value.length < len) {
+										value = "-0" + value.substring(1);
+									}
+								} else {
+									while(value.length < len) {
+										value = "0" + value;
+									}
 								}
 							} else {
 								len = parseInt(mod, 10) || 0;
@@ -354,57 +370,98 @@ const stringify = (obj) => {
 								}
 							}
 						}
+	
 						s.push(value);
+	
 					} else if(ch === "f") {
-						mod = mod.split(".");
-						if(mod.length === 2) {
-	                        len = parseInt(mod[1], 10) || 0;
-	                        value = arguments[i++];
-	                        var i1 = String.format("%" + mod[0] + "d", value);
-	                        var f = Math.abs(value - i1);
-							f *= Math.pow(10, len + 1);
-							f = "" + Math.round(Math.round(f) / 10);
-							while(f.length < len) {
-							    f = "0" + f;
+						var parts = mod.split(".");
+						var raw = Number(arguments[argi++]);
+	
+						if(parts.length === 2 && !isNaN(raw)) {
+							var widthSpec = parts[0];
+							var precision = parseInt(parts[1], 10);
+							if(isNaN(precision)) {
+								precision = 0;
+							}
+	
+							var negative = raw < 0 || (raw === 0 && 1 / raw < 0);
+							var abs = Math.abs(raw);
+							var fixed = abs.toFixed(precision);
+							var out = negative ? "-" + fixed : fixed;
+	
+							if(widthSpec.length) {
+								var width;
+	
+								if(widthSpec.charAt(0) === "0") {
+									width = parseInt(widthSpec.substring(1), 10) || 0;
+	
+									if(out.charAt(0) === "-") {
+										while(out.length < width) {
+											out = "-0" + out.substring(1);
+										}
+									} else {
+										while(out.length < width) {
+											out = "0" + out;
+										}
+									}
+								} else {
+									width = parseInt(widthSpec, 10) || 0;
+									while(out.length < width) {
+										out = " " + out;
+									}
+								}
 							}
-	                        s.push(i1 + "." + f);
-	                    } else {
-	                        s.push(arguments[i++]);
-	                    }
+	
+							s.push(out);
+						} else {
+							s.push(arguments[argi - 1]);
+						}
+	
 					} else if(ch === "s" || ch === "H" || ch === "n") {
+						var value;
+						var len;
+	
 						if(ch === "n") {
-							value = String.of(arguments[i++]);
+							value = String.of(arguments[argi++]);
 						} else {
-							value = "" + arguments[i++];
+							value = "" + arguments[argi++];
 						}
+	
 						if(mod.charAt(0) === "-") {
 							len = parseInt(mod.substring(1), 10) || 0;
 							while(value.length < len) {
-								value = " " + value;
+								value += " ";
 							}
 						} else {
 							len = parseInt(mod, 10) || 0;
 							if(mod === "*") {
 								len = parseInt(value, 10);
-								value = "" + arguments[i++];
+								value = "" + arguments[argi++];
 							}
 							while(value.length < len) {
-								value += " ";
+								value = " " + value;
 							}
 						}
+	
 						if(ch === "H" && value) {
 							try {
 								value = String.escapeHtml(value);
-							} catch(e) { value = e.message; }
+							} catch(e) {
+								value = e.message;
+							}
 						}
+	
 						s.push(value);
+	
 					} else {
-						s.push(arguments[i++]);
+						s.push(arguments[argi++]);
 					}
+	
 					pos = idx + 2;
 				}
 			}
 		} while(idx !== -1);
+	
 		s.push(fmt.substring(pos));
 		return s.join("");
 	};
@@ -455,7 +512,9 @@ const stringify = (obj) => {
 			n = parseFloat(n);
 			
 			if((i = r.indexOf("0000")) > dot) {
-				return n.toFixed(i - dot - 1);
+				var t = n.toFixed(i - dot - 1);
+				if(t === "0" && n > 0) return n;
+				return t;
 			}
 			if((i = r.indexOf("9999")) > dot) {
 				return n.toFixed(i - dot - 1);

package/src/locale.js

@@ -117,7 +117,7 @@ define(function(require) {
     		var arr = (window.locale.missing = (window.locale.missing || []));
     		arr.push(id);
         	// console.warn("undefined locale: " + id);
-        	r = "{" + id + "}";
+    		r = "{" + id + "}";
 		} else if(typeof r === "function" && r.name === "locale") {
 			/* automagically call functions named locale */		
 			r = r.apply(this, arguments);
@@ -172,11 +172,18 @@ define(function(require) {
     		} else {
     			args[0] = [prefix, id];
     		}
-    		return locale.apply(this, args);
+    		const r = locale.apply(this, args);
+    		if(typeof r === "string" && r.endsWith("}") && r.startsWith("{" + prefix)) {
+    			return "{" + r.substring(prefix.length + 1);
+    		}
+    		return r;
     	};
     	
     	prefixed.has = (id) => locale.has(prefix + id);
-    	
+    	prefixed.prefixed = (prefix2) => {
+    		return locale.prefixed(prefix + prefix2);
+    	};
+
     	return prefixed;
     };
 	locale.define = function(prefix, defaults) {