@schukai/monster 4.43.2 → 4.43.3

package/source/dom/slotted.mjs

@@ -28,46 +28,46 @@ export { getSlottedElements, getSlottedNodes };
  * @throws {Error} query must be a string
  */
 function getSlottedNodes(query, name) {
-  const result = new Set();
-
-  if (!this.shadowRoot) {
-    return result;
-  }
-
-  let selector = "slot";
-  if (name !== undefined) {
-    if (name === null) {
-      selector += ":not([name])";
-    } else {
-      selector += `[name=${validateString(name)}]`;
-    }
-  }
-
-  const slots = this.shadowRoot.querySelectorAll(selector);
-
-  for (const [, slot] of Object.entries(slots)) {
-    slot.assignedNodes().forEach(function (node) {
-      if (node === null || node === undefined) {
-        return;
-      }
-
-      if (isString(query)) {
-        node.querySelectorAll(query).forEach(function (n) {
-          result.add(n);
-        });
-
-        if (node.matches(query)) {
-          result.add(node);
-        }
-      } else if (query !== undefined) {
-        throw new Error("query must be a string");
-      } else {
-        result.add(node);
-      }
-    });
-  }
-
-  return result;
+	const result = new Set();
+
+	if (!this.shadowRoot) {
+		return result;
+	}
+
+	let selector = "slot";
+	if (name !== undefined) {
+		if (name === null) {
+			selector += ":not([name])";
+		} else {
+			selector += `[name=${validateString(name)}]`;
+		}
+	}
+
+	const slots = this.shadowRoot.querySelectorAll(selector);
+
+	for (const [, slot] of Object.entries(slots)) {
+		slot.assignedNodes().forEach(function (node) {
+			if (node === null || node === undefined) {
+				return;
+			}
+
+			if (isString(query)) {
+				node.querySelectorAll(query).forEach(function (n) {
+					result.add(n);
+				});
+
+				if (node.matches(query)) {
+					result.add(node);
+				}
+			} else if (query !== undefined) {
+				throw new Error("query must be a string");
+			} else {
+				result.add(node);
+			}
+		});
+	}
+
+	return result;
 }
 
 /**
@@ -81,51 +81,51 @@ function getSlottedNodes(query, name) {
  * @throws {Error} query must be a string
  */
 function getSlottedElements(query, name) {
-  const result = new Set();
-
-  if (!(this.shadowRoot instanceof ShadowRoot)) {
-    return result;
-  }
-
-  let selector = "slot";
-  if (name !== undefined) {
-    if (name === null) {
-      selector += ":not([name])";
-    } else {
-      selector += `[name=${validateString(name)}]`;
-    }
-  }
-
-  const slots = this.shadowRoot.querySelectorAll(selector);
-
-  for (const [, slot] of Object.entries(slots)) {
-    slot.assignedElements().forEach(function (node) {
-      if (
-        !(node instanceof HTMLElement) &&
-        !(node instanceof SVGElement) &&
-        !(node instanceof MathMLElement)
-      )
-        return;
-
-      if (isString(query)) {
-        if (query.length > 0) {
-          node.querySelectorAll(query).forEach(function (n) {
-            result.add(n);
-          });
-
-          if (node.matches(query)) {
-            result.add(node);
-          }
-        } else {
-          result.add(node);
-        }
-      } else if (query !== undefined) {
-        throw new Error("query must be a string and not empty");
-      } else {
-        result.add(node);
-      }
-    });
-  }
-
-  return result;
+	const result = new Set();
+
+	if (!(this.shadowRoot instanceof ShadowRoot)) {
+		return result;
+	}
+
+	let selector = "slot";
+	if (name !== undefined) {
+		if (name === null) {
+			selector += ":not([name])";
+		} else {
+			selector += `[name=${validateString(name)}]`;
+		}
+	}
+
+	const slots = this.shadowRoot.querySelectorAll(selector);
+
+	for (const [, slot] of Object.entries(slots)) {
+		slot.assignedElements().forEach(function (node) {
+			if (
+				!(node instanceof HTMLElement) &&
+				!(node instanceof SVGElement) &&
+				!(node instanceof MathMLElement)
+			)
+				return;
+
+			if (isString(query)) {
+				if (query.length > 0) {
+					node.querySelectorAll(query).forEach(function (n) {
+						result.add(n);
+					});
+
+					if (node.matches(query)) {
+						result.add(node);
+					}
+				} else {
+					result.add(node);
+				}
+			} else if (query !== undefined) {
+				throw new Error("query must be a string and not empty");
+			} else {
+				result.add(node);
+			}
+		});
+	}
+
+	return result;
 }

package/source/i18n/util.mjs

@@ -23,24 +23,24 @@ import { languages } from "./map/languages.mjs";
  * @return {number} The normalized number as a floating-point value. Returns NaN if the input is not a parsable number.
  */
 export function normalizeNumber(input, locale = navigator.language) {
-  if (input === null || input === undefined) return NaN;
-  if (typeof input === "number") return input; // If input is already a number, return it directly
-  if (typeof input !== "string") return NaN;
-
-  const cleaned = input.trim().replace(/\s/g, "");
-  const decimalSeparator = getDecimalSeparator(locale);
-  let normalized = cleaned;
-
-  if (decimalSeparator === "," && cleaned.includes(".")) {
-    normalized = cleaned.replace(/\./g, "").replace(",", ".");
-  } else if (decimalSeparator === "." && cleaned.includes(",")) {
-    normalized = cleaned.replace(/,/g, "").replace(".", ".");
-  } else if (decimalSeparator === "," && cleaned.includes(",")) {
-    normalized = cleaned.replace(",", ".");
-  }
-
-  const result = parseFloat(normalized);
-  return Number.isNaN(result) ? NaN : result;
+	if (input === null || input === undefined) return NaN;
+	if (typeof input === "number") return input; // If input is already a number, return it directly
+	if (typeof input !== "string") return NaN;
+
+	const cleaned = input.trim().replace(/\s/g, "");
+	const decimalSeparator = getDecimalSeparator(locale);
+	let normalized = cleaned;
+
+	if (decimalSeparator === "," && cleaned.includes(".")) {
+		normalized = cleaned.replace(/\./g, "").replace(",", ".");
+	} else if (decimalSeparator === "." && cleaned.includes(",")) {
+		normalized = cleaned.replace(/,/g, "").replace(".", ".");
+	} else if (decimalSeparator === "," && cleaned.includes(",")) {
+		normalized = cleaned.replace(",", ".");
+	}
+
+	const result = parseFloat(normalized);
+	return Number.isNaN(result) ? NaN : result;
 }
 
 /**
@@ -50,9 +50,9 @@ export function normalizeNumber(input, locale = navigator.language) {
  * @return {string} The decimal separator used in the specified locale.
  */
 function getDecimalSeparator(locale = navigator.language) {
-  const numberWithDecimal = 1.1;
-  const formatted = new Intl.NumberFormat(locale).format(numberWithDecimal);
-  return formatted.replace(/\d/g, "")[0]; // z.B. "," oder "."
+	const numberWithDecimal = 1.1;
+	const formatted = new Intl.NumberFormat(locale).format(numberWithDecimal);
+	return formatted.replace(/\d/g, "")[0]; // z.B. "," oder "."
 }
 
 /**
@@ -64,132 +64,132 @@ function getDecimalSeparator(locale = navigator.language) {
  * @return {Object} An object containing information about the detected language, preferred language, and available languages.
  */
 export function detectUserLanguagePreference() {
-  const currentLang = document.documentElement.lang;
-
-  let preferredLanguages = [];
-
-  if (typeof navigator.language === "string" && navigator.language.length > 0) {
-    preferredLanguages = [navigator.language];
-  }
-
-  if (Array.isArray(navigator.languages) && navigator.languages.length > 0) {
-    preferredLanguages = navigator.languages;
-  }
-
-  // add to preferredLanguages all the base languages of the preferred languages
-  preferredLanguages = preferredLanguages.concat(
-    preferredLanguages.map((lang) => lang.split("-")[0]),
-  );
-
-  if (!currentLang && preferredLanguages.length === 0) {
-    return {
-      message: "No language information available.",
-    };
-  }
-
-  const linkTags = document.querySelectorAll("link[hreflang]");
-  if (linkTags.length === 0) {
-    return {
-      current: currentLang || null,
-      message: "No <link> tags with hreflang available.",
-    };
-  }
-
-  const availableLanguages = [...linkTags].map((link) => {
-    const fullLang = link.getAttribute("hreflang");
-    const baseLang = fullLang.split("-")[0];
-    let label = link.getAttribute("data-monster-label");
-    if (!label) {
-      label = link.getAttribute("title");
-      if (!label) {
-        label = languages?.[fullLang];
-        if (!label) {
-          label = languages?.[baseLang];
-        }
-      }
-    }
-
-    return {
-      fullLang,
-      baseLang,
-      label,
-      href: link.getAttribute("href"),
-    };
-  });
-
-  // filter availableLanguages to only include languages that are in the preferredLanguages array
-  const offerableLanguages = availableLanguages.filter(
-    (lang) =>
-      preferredLanguages.includes(lang.fullLang) ||
-      preferredLanguages.includes(lang.baseLang),
-  );
-
-  const allOfferableLanguages = availableLanguages.filter(
-    (lang) => lang.baseLang !== currentLang && lang.fullLang !== currentLang,
-  );
-
-  if (offerableLanguages.length === 0) {
-    return {
-      current: currentLang || null,
-      message: "No available languages match the user's preferences.",
-      available: availableLanguages.map((lang) => ({
-        ...lang,
-        weight: 1,
-      })),
-      allOfferable: allOfferableLanguages,
-    };
-  }
-
-  // Helper function to determine the "weight" of a language match
-  function getWeight(langEntry) {
-    // Full match has priority 3
-    if (preferredLanguages.includes(langEntry.fullLang)) return 3;
-    // Base language match has priority 2
-    if (preferredLanguages.includes(langEntry.baseLang)) return 2;
-    // No match is priority 1
-    return 1;
-  }
-
-  // Sort the available languages by descending weight
-  offerableLanguages.sort((a, b) => getWeight(b) - getWeight(a));
-
-  // The best match is the first in the sorted list
-  const bestMatch = offerableLanguages[0];
-  const bestMatchWeight = getWeight(bestMatch);
-
-  const currentLabel = languages?.[currentLang] || currentLang;
-
-  // If we found a language that matches user preferences (weight > 0)
-  if (bestMatchWeight > 0) {
-    return {
-      current: currentLang || null,
-      currentLabel: currentLabel,
-      preferred: {
-        full: bestMatch.fullLang,
-        base: bestMatch.baseLang,
-        label: bestMatch.label,
-        href: bestMatch.href,
-      },
-      available: availableLanguages.map((lang) => ({
-        ...lang,
-        weight: getWeight(lang),
-      })),
-      offerable: offerableLanguages.map((lang) => ({
-        ...lang,
-        weight: getWeight(lang),
-      })),
-      allOfferable: allOfferableLanguages,
-    };
-  }
-
-  // If no language matched the user's preferences
-  return {
-    current: currentLang || null,
-    message: "None of the preferred languages are available.",
-    available: availableLanguages.map((lang) => ({
-      ...lang,
-      weight: getWeight(lang),
-    })),
-    allOfferable: allOfferableLanguages,
-  };
+	const currentLang = document.documentElement.lang;
+
+	let preferredLanguages = [];
+
+	if (typeof navigator.language === "string" && navigator.language.length > 0) {
+		preferredLanguages = [navigator.language];
+	}
+
+	if (Array.isArray(navigator.languages) && navigator.languages.length > 0) {
+		preferredLanguages = navigator.languages;
+	}
+
+	// add to preferredLanguages all the base languages of the preferred languages
+	preferredLanguages = preferredLanguages.concat(
+		preferredLanguages.map((lang) => lang.split("-")[0]),
+	);
+
+	if (!currentLang && preferredLanguages.length === 0) {
+		return {
+			message: "No language information available.",
+		};
+	}
+
+	const linkTags = document.querySelectorAll("link[hreflang]");
+	if (linkTags.length === 0) {
+		return {
+			current: currentLang || null,
+			message: "No <link> tags with hreflang available.",
+		};
+	}
+
+	const availableLanguages = [...linkTags].map((link) => {
+		const fullLang = link.getAttribute("hreflang");
+		const baseLang = fullLang.split("-")[0];
+		let label = link.getAttribute("data-monster-label");
+		if (!label) {
+			label = link.getAttribute("title");
+			if (!label) {
+				label = languages?.[fullLang];
+				if (!label) {
+					label = languages?.[baseLang];
+				}
+			}
+		}
+
+		return {
+			fullLang,
+			baseLang,
+			label,
+			href: link.getAttribute("href"),
+		};
+	});
+
+	// filter availableLanguages to only include languages that are in the preferredLanguages array
+	const offerableLanguages = availableLanguages.filter(
+		(lang) =>
+			preferredLanguages.includes(lang.fullLang) ||
+			preferredLanguages.includes(lang.baseLang),
+	);
+
+	const allOfferableLanguages = availableLanguages.filter(
+		(lang) => lang.baseLang !== currentLang && lang.fullLang !== currentLang,
+	);
+
+	if (offerableLanguages.length === 0) {
+		return {
+			current: currentLang || null,
+			message: "No available languages match the user's preferences.",
+			available: availableLanguages.map((lang) => ({
+				...lang,
+				weight: 1,
+			})),
+			allOfferable: allOfferableLanguages,
+		};
+	}
+
+	// Helper function to determine the "weight" of a language match
+	function getWeight(langEntry) {
+		// Full match has priority 3
+		if (preferredLanguages.includes(langEntry.fullLang)) return 3;
+		// Base language match has priority 2
+		if (preferredLanguages.includes(langEntry.baseLang)) return 2;
+		// No match is priority 1
+		return 1;
+	}
+
+	// Sort the available languages by descending weight
+	offerableLanguages.sort((a, b) => getWeight(b) - getWeight(a));
+
+	// The best match is the first in the sorted list
+	const bestMatch = offerableLanguages[0];
+	const bestMatchWeight = getWeight(bestMatch);
+
+	const currentLabel = languages?.[currentLang] || currentLang;
+
+	// If we found a language that matches user preferences (weight > 0)
+	if (bestMatchWeight > 0) {
+		return {
+			current: currentLang || null,
+			currentLabel: currentLabel,
+			preferred: {
+				full: bestMatch.fullLang,
+				base: bestMatch.baseLang,
+				label: bestMatch.label,
+				href: bestMatch.href,
+			},
+			available: availableLanguages.map((lang) => ({
+				...lang,
+				weight: getWeight(lang),
+			})),
+			offerable: offerableLanguages.map((lang) => ({
+				...lang,
+				weight: getWeight(lang),
+			})),
+			allOfferable: allOfferableLanguages,
+		};
+	}
+
+	// If no language matched the user's preferences
+	return {
+		current: currentLang || null,
+		message: "None of the preferred languages are available.",
+		available: availableLanguages.map((lang) => ({
+			...lang,
+			weight: getWeight(lang),
+		})),
+		allOfferable: allOfferableLanguages,
+	};
 }

package/source/monster.mjs

@@ -62,6 +62,7 @@ export * from "./components/form/api-button.mjs";
 export * from "./components/form/digits.mjs";
 export * from "./components/form/tree-select.mjs";
 export * from "./components/form/popper-button.mjs";
+export * from "./components/form/quantity.mjs";
 export * from "./components/form/input-group.mjs";
 export * from "./components/form/shadow-reload.mjs";
 export * from "./components/form/button.mjs";
@@ -106,12 +107,14 @@ export * from "./components/datatable/embedded-pagination.mjs";
 export * from "./components/datatable/status.mjs";
 export * from "./components/datatable/change-button.mjs";
 export * from "./components/datatable/constants.mjs";
+export * from "./components/accessibility/locale-select.mjs";
 export * from "./components/accessibility/locale-picker.mjs";
 export * from "./components/state/log/entry.mjs";
 export * from "./components/state/state.mjs";
 export * from "./components/state/log.mjs";
 export * from "./components/navigation/wizard-navigation.mjs";
 export * from "./components/navigation/table-of-content.mjs";
+export * from "./components/navigation/site-navigation.mjs";
 export * from "./components/data/metric-graph.mjs";
 export * from "./components/data/metric.mjs";
 export * from "./components/data/kpi-tile.mjs";