@schukai/monster 4.153.0 → 4.154.0

package/package.json

@@ -1 +1 @@
-{"author":"Volker Schukai","dependencies":{"@floating-ui/dom":"^1.7.6"},"description":"Monster is a simple library for creating fast, robust and lightweight websites.","files":["source","test/cases","test/util","CHANGELOG.md"],"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.153.0"}
+{"author":"Volker Schukai","dependencies":{"@floating-ui/dom":"^1.7.6"},"description":"Monster is a simple library for creating fast, robust and lightweight websites.","exports":{".":"./source/monster.mjs","./CHANGELOG.md":"./CHANGELOG.md","./LICENSE":"./LICENSE","./README.md":"./README.md","./package.json":"./package.json","./source/*":"./source/*","./test/*":"./test/*"},"files":["source","test/cases","test/util","CHANGELOG.md"],"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"},"sideEffects":["./source/monster.mjs","./source/components/**","./source/i18n/**","./test/**"],"type":"module","version":"4.154.0"}

package/source/components/form/message-state-button.mjs

@@ -333,8 +333,8 @@ class MessageStateButton extends Popper {
 	}
 
 	disconnectedCallback() {
-		clearAutoHideTimer.call(this);
 		super.disconnectedCallback();
+		clearAutoHideTimer.call(this);
 	}
 
 	/**

package/source/components/form/select-link.mjs

@@ -67,11 +67,22 @@ class SelectLink extends CustomElement {
 
 	[assembleMethodSymbol]() {
 		super[assembleMethodSymbol]();
-		bindSelects.call(this);
 		return this;
 	}
 
+	/**
+	 * Binding belongs to the connect lifecycle, not to assembly: disconnecting
+	 * unbinds, so a reconnect has to bind again. bindSelects() is idempotent.
+	 *
+	 * @inheritdoc
+	 */
+	connectedCallback() {
+		super.connectedCallback();
+		bindSelects.call(this);
+	}
+
 	disconnectedCallback() {
+		super.disconnectedCallback();
 		unbindSelects.call(this);
 	}
 }

package/source/components/state/log.mjs

@@ -136,13 +136,9 @@ class Log extends CustomElement {
 	 */
 	getOption(path, defaultValue = undefined) {
 		if (path === "entries" || path?.startsWith("entries.")) {
-			try {
-				return new Pathfinder({
-					entries: this[entriesSymbol],
-				}).getVia(path);
-			} catch (e) {
-				return defaultValue;
-			}
+			return new Pathfinder({
+				entries: this[entriesSymbol],
+			}).getVia(path, defaultValue);
 		}
 
 		return super.getOption(path, defaultValue);

package/source/components/state/thread.mjs

@@ -143,13 +143,9 @@ class Thread extends CustomElement {
 	 */
 	getOption(path, defaultValue = undefined) {
 		if (path === "entries" || path?.startsWith("entries.")) {
-			try {
-				return new Pathfinder({
-					entries: this[entriesSymbol],
-				}).getVia(path);
-			} catch (e) {
-				return defaultValue;
-			}
+			return new Pathfinder({
+				entries: this[entriesSymbol],
+			}).getVia(path, defaultValue);
 		}
 
 		return super.getOption(path, defaultValue);

package/source/components/time/day.mjs

@@ -363,25 +363,6 @@ function getLabels() {
 	}
 }
 
-/**
- * @private
- * @param format
- * @returns {*[]}
- */
-function getWeekdays(format = "long") {
-	const locale = getLocaleOfDocument();
-
-	const weekdays = [];
-	for (let i = 1; i < 8; i++) {
-		const date = new Date(1970, 0, 4 + i); // 4. Jan. 1970 = Sonntag
-		weekdays.push(
-			new Intl.DateTimeFormat(locale, { weekday: format }).format(date),
-		);
-	}
-
-	return weekdays;
-}
-
 /**
  * @private
  * @return {void}

package/source/components/time/month-calendar.mjs

@@ -363,7 +363,11 @@ function getAppointmentRowsUsingCalendar(
  * @returns {*[]}
  */
 function getWeekdays(format = "long") {
-	const locale = getLocaleOfDocument();
+	// Intl needs the language tag. Handing it the Locale instance makes
+	// CanonicalizeLocaleList treat the object as array like, and its missing
+	// length yields an empty locale list, so the formatter silently falls back
+	// to the host system locale and the document language is ignored.
+	const locale = getLocaleOfDocument().toString();
 
 	const weekdays = [];
 	for (let i = 1; i < 8; i++) {

package/source/data/buildmap.mjs

@@ -181,9 +181,9 @@ function buildFlatMap(subject, selector, key, parentMap) {
 			for (const [k, o] of map) {
 				const copyKey = clone(key);
 
-				currentPath.map((a) => {
-					copyKey.push(a === WILDCARD ? k : a);
-				});
+				for (const segment of currentPath) {
+					copyKey.push(segment === WILDCARD ? k : segment);
+				}
 
 				const kk = copyKey.join(DELIMITER);
 				const sub = buildFlatMap.call(
@@ -362,7 +362,8 @@ function buildFlatMap(subject, selector, key, parentMap) {
  * @return {*}
  */
 export function build(subject, definition, defaultValue) {
-	if (definition === undefined) return defaultValue ? defaultValue : subject;
+	if (definition === undefined)
+		return defaultValue !== undefined ? defaultValue : subject;
 	validateString(definition);
 
 	const regexp = /(?<placeholder>\${(?<path>[a-z\^A-Z.\-_0-9]*)})/gm;
@@ -384,7 +385,7 @@ export function build(subject, definition, defaultValue) {
 		let v = finder.getVia(path);
 		if (v === undefined) v = defaultValue;
 
-		definition = definition.replaceAll(placeholder, v);
+		definition = definition.replaceAll(placeholder, () => `${v}`);
 	});
 
 	return definition;

package/source/data/buildtree.mjs

@@ -21,12 +21,6 @@ import { extend } from "./extend.mjs";
 
 export { buildTree };
 
-/**
- * @private
- * @type {symbol}
- */
-const parentSymbol = Symbol("parent");
-
 /**
  * @private
  * @type {symbol}
@@ -171,8 +165,6 @@ function buildTree(subject, selector, idKey, parentIDKey, options) {
 			throw new Error("the object has no value for the specified id");
 		}
 
-		o[parentSymbol] = ref;
-
 		const node = new Node(o);
 		this.has(ref)
 			? this.get(ref).add(node)

package/source/data/datasource.mjs

@@ -165,16 +165,9 @@ class Datasource extends Base {
 	 * @return {*}
 	 */
 	getOption(path, defaultValue) {
-		let value;
-
-		try {
-			value = new Pathfinder(
-				this[internalSymbol].getRealSubject()["options"],
-			).getVia(path);
-		} catch (e) {}
-
-		if (value === undefined) return defaultValue;
-		return value;
+		return new Pathfinder(
+			this[internalSymbol].getRealSubject()["options"],
+		).getVia(path, defaultValue);
 	}
 
 	/**

package/source/data/diff.mjs

@@ -35,20 +35,15 @@ function diff(first, second) {
 }
 
 /**
+ * Own keys of both sides. Arrays are covered by this as well: their indices are
+ * own enumerable keys, and reporting them as string path segments is the
+ * established contract for every diff path.
  * @private
  * @param a
  * @param b
- * @param type
- * @return {Set<string>|Set<number>}
+ * @return {Set<string>}
  */
-function getKeys(a, b, type) {
-	if (isArray(type)) {
-		const keys =
-			a.length > b.length ? new Array(a.length) : new Array(b.length);
-		keys.fill(0);
-		return new Set(keys.map((_, i) => i));
-	}
-
+function getKeys(a, b) {
 	return new Set(Object.keys(a).concat(Object.keys(b)));
 }
 
@@ -68,7 +63,7 @@ function doDiff(a, b, path, diff) {
 	const currDiff = diff || [];
 
 	if (typeA === typeB && (typeA === "object" || typeA === "array")) {
-		const keys = getKeys(a, b, typeA);
+		const keys = getKeys(a, b);
 		if (keys.size === 0) {
 			return currDiff;
 		}
@@ -83,7 +78,7 @@ function doDiff(a, b, path, diff) {
 			}
 		});
 	} else {
-		const o = getOperator(a, b, typeA, typeB);
+		const o = getOperator(a, b);
 		if (o !== undefined) {
 			currDiff.push(buildResult(a, b, o, path));
 		}
@@ -153,6 +148,12 @@ function isNotEqual(a, b) {
 		return a.getTime() !== b.getTime();
 	}
 
+	// Two NaN values at the same path are the same value. Object.is() is not used
+	// here because it would additionally report 0 and -0 as a change.
+	if (Number.isNaN(a) && Number.isNaN(b)) {
+		return false;
+	}
+
 	return a !== b;
 }
 

package/source/data/extend.mjs

@@ -33,6 +33,16 @@ const unsafeMutationKeys = new Set(["__proto__", "prototype", "constructor"]);
  * @param args
  */
 function extend(...args) {
+	return extendValues(args, new Map());
+}
+
+/**
+ * @private
+ * @param {array} args
+ * @param {Map} path source objects currently being merged, mapped to their target
+ * @return {object}
+ */
+function extendValues(args, path) {
 	let o;
 	let i;
 
@@ -65,6 +75,13 @@ function extend(...args) {
 			}
 
 			if ((isObject(v) && typeOf(v) === "object") || isArray(v)) {
+				// A source object that is still being merged further up the call
+				// chain is a cycle. Reuse its target instead of recursing forever.
+				if (path.has(v)) {
+					o[k] = path.get(v);
+					continue;
+				}
+
 				if (o[k] === undefined) {
 					if (isArray(v)) {
 						o[k] = [];
@@ -87,7 +104,12 @@ function extend(...args) {
 					continue;
 				}
 
-				o[k] = extend(o[k], v);
+				path.set(v, o[k]);
+				try {
+					o[k] = extendValues([o[k], v], path);
+				} finally {
+					path.delete(v);
+				}
 			} else {
 				if (isArray(o)) {
 					o.push(v);

package/source/data/pathfinder.mjs

@@ -133,8 +133,14 @@ class Pathfinder extends Base {
 	}
 
 	/**
+	 * Reads the value at the given path.
+	 *
+	 * Without a second argument a path that cannot be traversed throws, and a
+	 * missing leaf resolves to undefined. With a second argument the value is
+	 * returned instead of the error, and also instead of an undefined result.
 	 *
 	 * @param {string|array} path
+	 * @param {*} defaultValue returned when the path cannot be resolved
 	 * @since 1.4.0
 	 * @return {*}
 	 * @throws {TypeError} unsupported type
@@ -143,8 +149,18 @@ class Pathfinder extends Base {
 	 * @throws {TypeError} value is not an integer
 	 * @throws {Error} unsupported action for this data type
 	 */
-	getVia(path) {
-		return getValueViaPath.call(this, this.object, path);
+	getVia(path, defaultValue) {
+		// Without a second argument the throwing contract is unchanged.
+		if (arguments.length < 2) {
+			return getValueViaPath.call(this, this.object, path);
+		}
+
+		const value = resolveValueViaPath.call(this, this.object, path, false);
+		if (value === NOT_FOUND || value === undefined) {
+			return defaultValue;
+		}
+
+		return value;
 	}
 
 	/**
@@ -189,13 +205,173 @@ class Pathfinder extends Base {
 	 * @since 1.4.0
 	 */
 	exists(path) {
+		return (
+			resolveValueViaPath.call(this, this.object, path, true) !== NOT_FOUND
+		);
+	}
+}
+
+/**
+ * Returned instead of throwing when a path cannot be resolved.
+ * @private
+ * @type {symbol}
+ */
+const NOT_FOUND = Symbol("@schukai/monster/data/pathfinder@@notFound");
+
+/**
+ * Split paths are memoized. getOption() resolves about 1393 option paths across
+ * the library, and the same handful of strings is used over and over.
+ * @private
+ * @type {Map<string, string[]>}
+ */
+const pathSplitCache = new Map();
+
+/**
+ * @private
+ * @type {number}
+ */
+const PATH_SPLIT_CACHE_LIMIT = 2048;
+
+/**
+ * The returned array is shared and must never be mutated by the caller.
+ * @private
+ * @param {string} path
+ * @return {string[]}
+ */
+function splitPath(path) {
+	const cached = pathSplitCache.get(path);
+	if (cached !== undefined) {
+		return cached;
+	}
+
+	const parts = path.split(DELIMITER);
+
+	if (pathSplitCache.size >= PATH_SPLIT_CACHE_LIMIT) {
+		pathSplitCache.clear();
+	}
+	pathSplitCache.set(path, parts);
+
+	return parts;
+}
+
+/**
+ * A complete integer path segment, or undefined when the segment is not one.
+ * @private
+ * @param {*} value
+ * @return {number|undefined}
+ */
+function toPathIndex(value) {
+	if (!/^-?\d+$/.test(`${value}`)) {
+		return undefined;
+	}
+
+	const index = Number(value);
+	if (!Number.isInteger(index)) {
+		return undefined;
+	}
+
+	return index;
+}
+
+/**
+ * Non throwing counterpart of getValueViaPath(). Returns NOT_FOUND instead of
+ * throwing, so that resolving an option does not construct an exception, and
+ * walks the path iteratively instead of copying and shifting it per segment.
+ *
+ * The membership semantics of `check` are the ones exists() relies on: a key
+ * that is present with value undefined counts as found, and a malformed path is
+ * simply not found rather than an error.
+ *
+ * @private
+ * @param {*} subject
+ * @param {string|array} path
+ * @param {boolean} check
+ * @return {*|symbol} the resolved value or NOT_FOUND
+ */
+function resolveValueViaPath(subject, path, check) {
+	let parts;
+	if (isArray(path)) {
+		if (path.length === 0) {
+			return subject;
+		}
+		parts = path;
+	} else if (isString(path)) {
+		if (path === "") {
+			return subject;
+		}
+		parts = splitPath(path);
+	} else {
+		return NOT_FOUND;
+	}
+
+	// A wildcard builds a Map through iterate(), which stays on the throwing
+	// implementation. Those paths are rare, so fall back for them.
+	if (parts.includes(this.wildCard)) {
 		try {
-			getValueViaPath.call(this, this.object, path, true);
-			return true;
-		} catch (e) {}
+			return getValueViaPath.call(this, subject, path, check === true);
+		} catch (e) {
+			return NOT_FOUND;
+		}
+	}
+
+	let cursor = subject;
+	const last = parts.length - 1;
+
+	for (let i = 0; i <= last; i++) {
+		if (!(isObject(cursor) || isArray(cursor))) {
+			return NOT_FOUND;
+		}
+
+		if (cursor instanceof WeakSet) {
+			return NOT_FOUND;
+		}
+
+		if (typeof WeakRef === "function" && cursor instanceof WeakRef) {
+			return NOT_FOUND;
+		}
+
+		const segment = parts[i];
+		const isLast = i === last;
+		let value;
+
+		if (cursor instanceof Map || cursor instanceof WeakMap) {
+			if (isLast && check === true && !cursor.has(segment)) {
+				return NOT_FOUND;
+			}
+			value = cursor.get(segment);
+		} else if (cursor instanceof Set) {
+			const index = toPathIndex(segment);
+			if (index === undefined) {
+				return NOT_FOUND;
+			}
+			if (isLast && check === true && !(index >= 0 && index < cursor.size)) {
+				return NOT_FOUND;
+			}
+			value = [...cursor][index];
+		} else if (isArray(cursor)) {
+			const index = toPathIndex(segment);
+			if (index === undefined) {
+				return NOT_FOUND;
+			}
+			if (isLast && check === true && !Reflect.has(cursor, index)) {
+				return NOT_FOUND;
+			}
+			value = cursor[index];
+		} else {
+			if (isLast && check === true && !Reflect.has(cursor, segment)) {
+				return NOT_FOUND;
+			}
+			value = cursor[segment];
+		}
+
+		if (isLast) {
+			return value;
+		}
 
-		return false;
+		cursor = value;
 	}
+
+	return NOT_FOUND;
 }
 
 /**
@@ -217,16 +393,21 @@ function iterate(subject, path, check) {
 
 	const result = new Map();
 
-	if (isArray(path)) {
-		path = path.join(DELIMITER);
-	}
-
-	if (isObject(subject) || isArray(subject)) {
+	if (subject instanceof Map) {
+		for (const [key, value] of subject) {
+			result.set(key, getValueViaPath.call(this, value, path, check));
+		}
+	} else if (subject instanceof Set) {
+		let index = 0;
+		for (const value of subject) {
+			result.set(`${index++}`, getValueViaPath.call(this, value, path, check));
+		}
+	} else if (isObject(subject) || isArray(subject)) {
 		for (const [key, value] of Object.entries(subject)) {
 			result.set(key, getValueViaPath.call(this, value, path, check));
 		}
 	} else {
-		const key = path.split(DELIMITER).shift();
+		const key = isArray(path) ? path[0] : path.split(DELIMITER).shift();
 		result.set(key, getValueViaPath.call(this, subject, path, check));
 	}
 
@@ -272,7 +453,7 @@ function getValueViaPath(subject, path, check) {
 	let current = parts.shift();
 
 	if (current === this.wildCard) {
-		return iterate.call(this, subject, parts.join(DELIMITER), check);
+		return iterate.call(this, subject, parts, check);
 	}
 
 	if (isObject(subject) || isArray(subject)) {
@@ -280,23 +461,21 @@ function getValueViaPath(subject, path, check) {
 		if (subject instanceof Map || subject instanceof WeakMap) {
 			anchor = subject.get(current);
 		} else if (subject instanceof Set) {
-			current = parseInt(current);
-			validateInteger(current);
+			current = parsePathIndex(current);
 			anchor = [...subject]?.[current];
 		} else if (subject instanceof WeakSet) {
 			throw Error("unsupported action for this data type (WeakSet)");
 		} else if (typeof WeakRef === "function" && subject instanceof WeakRef) {
 			throw Error("unsupported action for this data type (WeakRef)");
 		} else if (isArray(subject)) {
-			current = parseInt(current);
-			validateInteger(current);
+			current = parsePathIndex(current);
 			anchor = subject?.[current];
 		} else {
 			anchor = subject?.[current];
 		}
 
 		if (isObject(anchor) || isArray(anchor)) {
-			return getValueViaPath.call(this, anchor, parts.join(DELIMITER), check);
+			return getValueViaPath.call(this, anchor, parts, check);
 		}
 
 		if (parts.length > 0) {
@@ -304,12 +483,18 @@ function getValueViaPath(subject, path, check) {
 		}
 
 		if (check === true) {
-			const descriptor = Object.getOwnPropertyDescriptor(
-				Object.getPrototypeOf(subject),
-				current,
-			);
+			let exists;
+			if (subject instanceof Map || subject instanceof WeakMap) {
+				exists = subject.has(current);
+			} else if (subject instanceof Set) {
+				exists = current >= 0 && current < subject.size;
+			} else if (isArray(subject)) {
+				exists = Reflect.has(subject, current);
+			} else {
+				exists = Reflect.has(subject, current);
+			}
 
-			if (!subject.hasOwnProperty(current) && descriptor === undefined) {
+			if (!exists) {
 				throw Error("unknown value " + current);
 			}
 		}
@@ -411,16 +596,25 @@ function setValueViaPath(subject, path, value) {
  * @param {*} value
  */
 function assignProperty(object, key, value) {
-	if (!object.hasOwnProperty(key)) {
-		object[key] = value;
-		return;
-	}
+	// Writing undefined keeps the key. Deletion is deliberately left to
+	// deleteVia(), because a default option declared as undefined must stay
+	// present for setOptionFromAttribute() to keep accepting changes for it.
+	object[key] = value;
+}
 
-	if (value === undefined) {
-		delete object[key];
+/**
+ * Convert a complete integer path segment without accepting trailing text.
+ * @param {*} value
+ * @return {number}
+ * @private
+ */
+function parsePathIndex(value) {
+	if (!/^-?\d+$/.test(`${value}`)) {
+		throw new TypeError("value is not an integer");
 	}
-
-	object[key] = value;
+	const index = Number(value);
+	validateInteger(index);
+	return index;
 }
 
 /**
@@ -486,7 +680,9 @@ function deleteValueViaPath(subject, path) {
  * @private
  */
 function validateMutationPath(path) {
-	const parts = isArray(path) ? path : path.split(DELIMITER);
+	const parts = (isArray(path) ? path : [path]).flatMap((part) =>
+		`${part}`.split(DELIMITER),
+	);
 	for (const part of parts) {
 		if (UNSAFE_MUTATION_PATH_SEGMENTS.has(`${part}`)) {
 			throw new Error(`unsafe mutation path segment: ${part}`);

package/source/data/transformer.mjs

@@ -530,7 +530,7 @@ function transform(value) {
 
 			const useKey = keys?.[key];
 
-			if (value?.[useKey]) {
+			if (useKey !== undefined && Reflect.has(value, useKey)) {
 				return value?.[useKey];
 			}
 
@@ -555,7 +555,7 @@ function transform(value) {
 			}
 
 			if (isObject(value) || isArray(value)) {
-				if (value?.[key]) {
+				if (Reflect.has(value, key)) {
 					return value?.[key];
 				}