@schukai/monster 3.96.2 → 3.97.0

package/source/i18n/locale.mjs

@@ -12,12 +12,12 @@
  * SPDX-License-Identifier: AGPL-3.0
  */
 
-import { instanceSymbol } from "../constants.mjs";
-import { Base } from "../types/base.mjs";
-import { validateString } from "../types/validate.mjs";
-import { clone } from "../util/clone.mjs";
+import {instanceSymbol} from "../constants.mjs";
+import {Base} from "../types/base.mjs";
+import {validateString} from "../types/validate.mjs";
+import {clone} from "../util/clone.mjs";
 
-export { Locale, parseLocale };
+export {Locale, parseLocale};
 
 /**
  * @type {symbol}
@@ -69,116 +69,116 @@ const localeStringSymbol = Symbol("localeString");
  * @see https://datatracker.ietf.org/doc/html/rfc3066
  */
 class Locale extends Base {
-	/**
-	 * @param {string} language
-	 * @param {string} [region]
-	 * @param {string} [script]
-	 * @param {string} [variants]
-	 * @param {string} [extlang]
-	 * @param {string} [privateUse]
-	 * @throws {Error} unsupported locale
-	 */
-	constructor(language, region, script, variants, extlang, privateUse) {
-		super();
+    /**
+     * @param {string} language
+     * @param {string} [region]
+     * @param {string} [script]
+     * @param {string} [variants]
+     * @param {string} [extlang]
+     * @param {string} [privateUse]
+     * @throws {Error} unsupported locale
+     */
+    constructor(language, region, script, variants, extlang, privateUse) {
+        super();
 
-		this[propertiesSymbol] = {
-			language: language === undefined ? undefined : validateString(language),
-			script: script === undefined ? undefined : validateString(script),
-			region: region === undefined ? undefined : validateString(region),
-			variants: variants === undefined ? undefined : validateString(variants),
-			extlang: extlang === undefined ? undefined : validateString(extlang),
-			privateUse:
-				privateUse === undefined ? undefined : validateString(privateUse),
-		};
+        this[propertiesSymbol] = {
+            language: language === undefined ? undefined : validateString(language),
+            script: script === undefined ? undefined : validateString(script),
+            region: region === undefined ? undefined : validateString(region),
+            variants: variants === undefined ? undefined : validateString(variants),
+            extlang: extlang === undefined ? undefined : validateString(extlang),
+            privateUse:
+                privateUse === undefined ? undefined : validateString(privateUse),
+        };
 
-		const s = [];
-		if (language !== undefined) s.push(language);
-		if (script !== undefined) s.push(script);
-		if (region !== undefined) s.push(region);
-		if (variants !== undefined) s.push(variants);
-		if (extlang !== undefined) s.push(extlang);
-		if (privateUse !== undefined) s.push(privateUse);
+        const s = [];
+        if (language !== undefined) s.push(language);
+        if (script !== undefined) s.push(script);
+        if (region !== undefined) s.push(region);
+        if (variants !== undefined) s.push(variants);
+        if (extlang !== undefined) s.push(extlang);
+        if (privateUse !== undefined) s.push(privateUse);
 
-		if (s.length === 0) {
-			throw new Error("unsupported locale");
-		}
+        if (s.length === 0) {
+            throw new Error("unsupported locale");
+        }
 
-		this[localeStringSymbol] = s.join("-");
-	}
+        this[localeStringSymbol] = s.join("-");
+    }
 
-	/**
-	 * This method is called by the `instanceof` operator.
-	 * @return {symbol}
-	 * @since 3.27.0
-	 */
-	static get [instanceSymbol]() {
-		return Symbol.for("@schukai/monster/i18n/locale@@instance");
-	}
+    /**
+     * This method is called by the `instanceof` operator.
+     * @return {symbol}
+     * @since 3.27.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/i18n/locale@@instance");
+    }
 
-	/**
-	 * @return {string}
-	 */
-	get localeString() {
-		return this[localeStringSymbol];
-	}
+    /**
+     * @return {string}
+     */
+    get localeString() {
+        return this[localeStringSymbol];
+    }
 
-	/**
-	 * @return {string|undefined}
-	 */
-	get language() {
-		return this[propertiesSymbol].language;
-	}
+    /**
+     * @return {string|undefined}
+     */
+    get language() {
+        return this[propertiesSymbol].language;
+    }
 
-	/**
-	 * @return {string|undefined}
-	 */
-	get region() {
-		return this[propertiesSymbol].region;
-	}
+    /**
+     * @return {string|undefined}
+     */
+    get region() {
+        return this[propertiesSymbol].region;
+    }
 
-	/**
-	 * @return {string|undefined}
-	 */
-	get script() {
-		return this[propertiesSymbol].script;
-	}
+    /**
+     * @return {string|undefined}
+     */
+    get script() {
+        return this[propertiesSymbol].script;
+    }
 
-	/**
-	 * @return {string|undefined}
-	 */
-	get variants() {
-		return this[propertiesSymbol].variants;
-	}
+    /**
+     * @return {string|undefined}
+     */
+    get variants() {
+        return this[propertiesSymbol].variants;
+    }
 
-	/**
-	 * @return {string|undefined}
-	 */
-	get extlang() {
-		return this[propertiesSymbol].extlang;
-	}
+    /**
+     * @return {string|undefined}
+     */
+    get extlang() {
+        return this[propertiesSymbol].extlang;
+    }
 
-	/**
-	 * @return {string|undefined}
-	 */
-	get privateUse() {
-		return this[propertiesSymbol].privateValue;
-	}
+    /**
+     * @return {string|undefined}
+     */
+    get privateUse() {
+        return this[propertiesSymbol].privateValue;
+    }
 
-	/**
-	 * @return {string}
-	 */
-	toString() {
-		return `${this.localeString}`;
-	}
+    /**
+     * @return {string}
+     */
+    toString() {
+        return `${this.localeString}`;
+    }
 
-	/**
-	 * The structure has the following: language, script, region, variants, extlang, privateUse
-	 *
-	 * @return {Monster.I18n.LocaleMap}
-	 */
-	getMap() {
-		return clone(this[propertiesSymbol]);
-	}
+    /**
+     * The structure has the following: language, script, region, variants, extlang, privateUse
+     *
+     * @return {Monster.I18n.LocaleMap}
+     */
+    getMap() {
+        return clone(this[propertiesSymbol]);
+    }
 }
 
 /**
@@ -260,63 +260,63 @@ class Locale extends Base {
  * @throws {Error} unsupported locale
  */
 function parseLocale(locale) {
-	locale = validateString(locale).replace(/_/g, "-");
+    locale = validateString(locale).replace(/_/g, "-");
 
-	let language;
-	let region;
-	let variants;
-	let parts;
-	let script;
-	let extlang;
-	const regexRegular =
-		"(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)";
-	const regexIrregular =
-		"(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)";
-	const regexGrandfathered = `(${regexIrregular}|${regexRegular})`;
-	const regexPrivateUse = "(x(-[A-Za-z0-9]{1,8})+)";
-	const regexSingleton = "[0-9A-WY-Za-wy-z]";
-	const regexExtension = `(${regexSingleton}(-[A-Za-z0-9]{2,8})+)`;
-	const regexVariant = "([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})";
-	const regexRegion = "([A-Za-z]{2}|[0-9]{3})";
-	const regexScript = "([A-Za-z]{4})";
-	const regexExtlang = "([A-Za-z]{3}(-[A-Za-z]{3}){0,2})";
-	const regexLanguage = `(([A-Za-z]{2,3}(-${regexExtlang})?)|[A-Za-z]{4}|[A-Za-z]{5,8})`;
-	const regexLangtag = `(${regexLanguage}(-${regexScript})?(-${regexRegion})?(-${regexVariant})*(-${regexExtension})*(-${regexPrivateUse})?)`;
-	const regexLanguageTag = `^(${regexGrandfathered}|${regexLangtag}|${regexPrivateUse})$`;
-	const regex = new RegExp(regexLanguageTag);
-	let match;
+    let language;
+    let region;
+    let variants;
+    let parts;
+    let script;
+    let extlang;
+    const regexRegular =
+        "(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)";
+    const regexIrregular =
+        "(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)";
+    const regexGrandfathered = `(${regexIrregular}|${regexRegular})`;
+    const regexPrivateUse = "(x(-[A-Za-z0-9]{1,8})+)";
+    const regexSingleton = "[0-9A-WY-Za-wy-z]";
+    const regexExtension = `(${regexSingleton}(-[A-Za-z0-9]{2,8})+)`;
+    const regexVariant = "([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})";
+    const regexRegion = "([A-Za-z]{2}|[0-9]{3})";
+    const regexScript = "([A-Za-z]{4})";
+    const regexExtlang = "([A-Za-z]{3}(-[A-Za-z]{3}){0,2})";
+    const regexLanguage = `(([A-Za-z]{2,3}(-${regexExtlang})?)|[A-Za-z]{4}|[A-Za-z]{5,8})`;
+    const regexLangtag = `(${regexLanguage}(-${regexScript})?(-${regexRegion})?(-${regexVariant})*(-${regexExtension})*(-${regexPrivateUse})?)`;
+    const regexLanguageTag = `^(${regexGrandfathered}|${regexLangtag}|${regexPrivateUse})$`;
+    const regex = new RegExp(regexLanguageTag);
+    let match;
 
-	if ((match = regex.exec(locale)) !== null) {
-		if (match.index === regex.lastIndex) {
-			regex.lastIndex++;
-		}
-	}
+    if ((match = regex.exec(locale)) !== null) {
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+    }
 
-	if (match === undefined || match === null) {
-		throw new Error("unsupported locale");
-	}
+    if (match === undefined || match === null) {
+        throw new Error("unsupported locale");
+    }
 
-	if (match[6] !== undefined) {
-		language = match[6];
+    if (match[6] !== undefined) {
+        language = match[6];
 
-		parts = language.split("-");
-		if (parts.length > 1) {
-			language = parts[0];
-			extlang = parts[1];
-		}
-	}
+        parts = language.split("-");
+        if (parts.length > 1) {
+            language = parts[0];
+            extlang = parts[1];
+        }
+    }
 
-	if (match[14] !== undefined) {
-		region = match[14];
-	}
+    if (match[14] !== undefined) {
+        region = match[14];
+    }
 
-	if (match[12] !== undefined) {
-		script = match[12];
-	}
+    if (match[12] !== undefined) {
+        script = match[12];
+    }
 
-	if (match[16] !== undefined) {
-		variants = match[16];
-	}
+    if (match[16] !== undefined) {
+        variants = match[16];
+    }
 
-	return new Locale(language, region, script, variants, extlang);
+    return new Locale(language, region, script, variants, extlang);
 }

package/source/i18n/map/languages.mjs

@@ -0,0 +1,104 @@
+/**
+ * Copyright © schukai GmbH and all contributing authors, {{copyRightYear}}. All rights reserved.
+ * Node module: @schukai/monster
+ *
+ * This source code is licensed under the GNU Affero General Public License version 3 (AGPLv3).
+ * The full text of the license can be found at: https://www.gnu.org/licenses/agpl-3.0.en.html
+ *
+ * For those who do not wish to adhere to the AGPLv3, a commercial license is available.
+ * Acquiring a commercial license allows you to use this software without complying with the AGPLv3 terms.
+ * For more information about purchasing a commercial license, please contact schukai GmbH.
+ *
+ * SPDX-License-Identifier: AGPL-3.0
+ */
+
+export const languages = {
+    "en": "English",
+    "en-GB": "English (United Kingdom)",
+    "en-US": "English (United States)",
+    "en-CA": "English (Canada)",
+    "en-AU": "English (Australia)",
+    "es": "Español",
+    "es-ES": "Español (España)",
+    "es-MX": "Español (México)",
+    "es-AR": "Español (Argentina)",
+    "zh": "中文",
+    "zh-CN": "中文（简体）",
+    "zh-TW": "中文（繁體）",
+    "zh-HK": "中文（香港）",
+    "fr": "Français",
+    "fr-FR": "Français (France)",
+    "fr-CA": "Français (Canada)",
+    "fr-BE": "Français (Belgique)",
+    "de": "Deutsch",
+    "de-DE": "Deutsch (Deutschland)",
+    "de-AT": "Deutsch (Österreich)",
+    "de-CH": "Deutsch (Schweiz)",
+    "ja": "日本語",
+    "ru": "Русский",
+    "ru-RU": "Русский (Россия)",
+    "it": "Italiano",
+    "it-IT": "Italiano (Italia)",
+    "pt": "Português",
+    "pt-PT": "Português (Portugal)",
+    "pt-BR": "Português (Brasil)",
+    "ko": "한국어",
+    "ar": "العربية",
+    "hi": "हिन्दी",
+    "bn": "বাংলা",
+    "pa": "ਪੰਜਾਬੀ",
+    "id": "Bahasa Indonesia",
+    "vi": "Tiếng Việt",
+    "tr": "Türkçe",
+    "tr-TR": "Türkçe (Türkiye)",
+    "pl": "Polski",
+    "pl-PL": "Polski (Polska)",
+    "uk": "Українська",
+    "uk-UA": "Українська (Україна)",
+    "ro": "Română",
+    "ro-RO": "Română (România)",
+    "nl": "Nederlands",
+    "nl-NL": "Nederlands (Nederland)",
+    "el": "Ελληνικά",
+    "el-GR": "Ελληνικά (Ελλάδα)",
+    "hu": "Magyar",
+    "hu-HU": "Magyar (Magyarország)",
+    "sv": "Svenska",
+    "sv-SE": "Svenska (Sverige)",
+    "cs": "Čeština",
+    "cs-CZ": "Čeština (Česká republika)",
+    "bg": "Български",
+    "bg-BG": "Български (България)",
+    "da": "Dansk",
+    "da-DK": "Dansk (Danmark)",
+    "fi": "Suomi",
+    "fi-FI": "Suomi (Suomi)",
+    "sk": "Slovenčina",
+    "sk-SK": "Slovenčina (Slovensko)",
+    "he": "עברית",
+    "th": "ไทย",
+    "sr": "Српски",
+    "sr-RS": "Српски (Србија)",
+    "no": "Norsk",
+    "no-NO": "Norsk (Norge)",
+    "lt": "Lietuvių",
+    "lt-LT": "Lietuvių (Lietuva)",
+    "lv": "Latviešu",
+    "lv-LV": "Latviešu (Latvija)",
+    "et": "Eesti",
+    "et-EE": "Eesti (Eesti)",
+    "hr": "Hrvatski",
+    "hr-HR": "Hrvatski (Hrvatska)",
+    "sl": "Slovenščina",
+    "sl-SI": "Slovenščina (Slovenija)",
+    "mt": "Malti",
+    "mt-MT": "Malti (Malta)",
+    "is": "Íslenska",
+    "is-IS": "Íslenska (Ísland)",
+    "ga": "Gaeilge",
+    "ga-IE": "Gaeilge (Éire)",
+    "cy": "Cymraeg",
+    "cy-GB": "Cymraeg (Y Deyrnas Unedig)",
+    "sq": "Shqip",
+    "sq-AL": "Shqip (Shqipëria)"
+};

package/source/i18n/util.mjs

@@ -0,0 +1,139 @@
+/**
+ * Copyright © schukai GmbH and all contributing authors, {{copyRightYear}}. All rights reserved.
+ * Node module: @schukai/monster
+ *
+ * This source code is licensed under the GNU Affero General Public License version 3 (AGPLv3).
+ * The full text of the license can be found at: https://www.gnu.org/licenses/agpl-3.0.en.html
+ *
+ * For those who do not wish to adhere to the AGPLv3, a commercial license is available.
+ * Acquiring a commercial license allows you to use this software without complying with the AGPLv3 terms.
+ * For more information about purchasing a commercial license, please contact schukai GmbH.
+ *
+ * SPDX-License-Identifier: AGPL-3.0
+ */
+
+import {languages} from "./map/languages.mjs";
+
+/**
+ * Determines the user's preferred language based on browser settings and available language options.
+ *
+ * It evaluates the current HTML document language, the browser's defined languages, and
+ * the language options from `<link>` elements with `hreflang` attributes in the document.
+ *
+ * @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.hreflang;
+        const baseLang = fullLang.split("-")[0];
+        let label = link.getAttribute('data-monster-label')
+        if (!label) {
+            label = languages?.[fullLang]
+            if (!label) {
+                label = languages?.[baseLang]
+            }
+        }
+
+        return {
+            fullLang,
+            baseLang,
+            label,
+            href: link.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));
+
+    if (offerableLanguages.length === 0) {
+        return {
+            current: currentLang || null,
+            message: "No available languages match the user's preferences.",
+            available: availableLanguages.map((lang) => ({
+                ...lang,
+                weight: 1,
+            })),
+        };
+    }
+
+    // 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 > 1)
+    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),
+            })),
+        };
+    }
+
+    // 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),
+        })),
+    };
+}

package/source/monster.mjs

@@ -1,5 +1,5 @@
 /**
- * Copyright © schukai GmbH and all contributing authors, 2024. All rights reserved.
+ * Copyright © schukai GmbH and all contributing authors, 2025. All rights reserved.
  * Node module: @schukai/monster
  *
  * This source code is licensed under the GNU Affero General Public License version 3 (AGPLv3).

package/source/text/formatter.mjs

@@ -276,7 +276,10 @@ function format(text) {
  * @private
  * @license AGPLv3
  * @since 1.12.0
- * @param text
+ *
+ * @param {string} text
+ * @param {string} openMarker
+ * @param {string} closeMarker
  * @return {string}
  */
 function tokenize(text, openMarker, closeMarker) {
@@ -339,7 +342,7 @@ function tokenize(text, openMarker, closeMarker) {
 		const t1 = key.split("|").shift().trim(); // pipe symbol
 		const t2 = t1.split("::").shift().trim(); // key value delimiter
 		const t3 = t2.split(".").shift().trim(); // path delimiter
-		const prefix = this[workingDataSymbol]?.[t3] ? "path:" : "static:";
+		const prefix = t3 in this[workingDataSymbol] ? "path:" : "static:";
 
 		let command = "";
 		if (
@@ -362,7 +365,6 @@ function tokenize(text, openMarker, closeMarker) {
 		}
 
 		formatted.push(validateString(pipe.run(this[workingDataSymbol])));
-
 		text = text.substring(endIndex + closeMarker.length);
 	}
 

package/source/types/is.mjs

@@ -12,6 +12,8 @@
  * SPDX-License-Identifier: AGPL-3.0
  */
 
+import { proxyInstanceMarker } from "../constants.mjs";
+
 export {
 	isIterable,
 	isPrimitive,
@@ -23,8 +25,19 @@ export {
 	isArray,
 	isFunction,
 	isInteger,
+	isProxy,
 };
 
+/**
+ * Checks whether the value passed is a Proxy.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+function isProxy(value) {
+	return value?.[proxyInstanceMarker] === proxyInstanceMarker;
+}
+
 /**
  * With this function you can check if a value is iterable.
  *