@schukai/monster 4.153.1 → 4.154.1

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.1"}
+{"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.1"}

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(

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;
+		}
+	}
 
-		return false;
+	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;
+		}
+
+		cursor = value;
 	}
+
+	return NOT_FOUND;
 }
 
 /**
@@ -224,10 +400,7 @@ function iterate(subject, path, check) {
 	} else if (subject instanceof Set) {
 		let index = 0;
 		for (const value of subject) {
-			result.set(
-				`${index++}`,
-				getValueViaPath.call(this, value, path, check),
-			);
+			result.set(`${index++}`, getValueViaPath.call(this, value, path, check));
 		}
 	} else if (isObject(subject) || isArray(subject)) {
 		for (const [key, value] of Object.entries(subject)) {
@@ -423,15 +596,9 @@ function setValueViaPath(subject, path, value) {
  * @param {*} value
  */
 function assignProperty(object, key, value) {
-	if (!Object.hasOwn(object, key)) {
-		object[key] = value;
-		return;
-	}
-
-	if (value === undefined) {
-		delete object[key];
-	}
-
+	// 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;
 }