@schukai/monster 4.150.0 → 4.150.2

package/test/cases/components/form/register-wizard.mjs

@@ -18,6 +18,21 @@ describe("RegisterWizard", () => {
 
 	afterEach(() => {
 		document.getElementById("mocks").replaceChildren();
+		document.documentElement.lang = "en";
+	});
+
+	it("uses native localized defaults", () => {
+		for (const [locale, option, expected] of [
+			["de", "labels.street", "Straße"],
+			["hi", "labels.successTitle", "पंजीकरण पूरा हुआ"],
+			["ru", "labels.stepAccount", "Учётная запись"],
+			["ja", "labels.successTitle", "登録完了"],
+			["fi", "labels.email", "Sähköposti"],
+		]) {
+			document.documentElement.lang = locale;
+			const element = document.createElement("monster-register-wizard");
+			assert.equal(element.getOption(option), expected, `${locale}:${option}`);
+		}
 	});
 
 	it("keeps explicit labels inside nested field sets", async () => {

package/test/cases/components/form/toggle-switch.mjs

@@ -73,6 +73,19 @@ describe('ToggleSwitch', function () {
             it('should instance of monster-toggle-switch', function () {
                 expect(document.createElement('monster-toggle-switch')).is.instanceof(ToggleSwitch);
             });
+
+            it('should center the visual switch within the themed control height', function () {
+                const cssText = ToggleSwitch.getCSSStyleSheet()
+                    .flatMap((styleSheet) => Array.from(styleSheet.cssRules))
+                    .map((rule) => rule.cssText)
+                    .join("\n");
+
+                expect(cssText).to.contain("min-block-size: inherit");
+                expect(cssText).to.contain("align-items: center");
+                expect(cssText).to.match(
+                    /:host\s*\{[^}]*min-block-size:\s*var\(--monster-control-min-block-size,\s*1\.8rem\)/u,
+                );
+            });
         });
 
     });

package/test/cases/i18n/built-in-locales.mjs

@@ -0,0 +1,151 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect } from "chai";
+import * as espree from "espree";
+import { globSync } from "glob";
+import { currentSupportedLanguages } from "../../../source/i18n/map/languages.mjs";
+
+const repositoryRoot = resolve(
+	dirname(fileURLToPath(import.meta.url)),
+	"../../..",
+);
+const sourceFiles = globSync("source/**/*.mjs", {
+	cwd: repositoryRoot,
+	absolute: true,
+});
+
+function walk(node, callback) {
+	if (!node || typeof node !== "object") {
+		return;
+	}
+
+	if (typeof node.type === "string") {
+		callback(node);
+	}
+
+	for (const [key, value] of Object.entries(node)) {
+		if (["comments", "loc", "range", "tokens"].includes(key)) {
+			continue;
+		}
+		if (Array.isArray(value)) {
+			for (const child of value) {
+				walk(child, callback);
+			}
+		} else {
+			walk(value, callback);
+		}
+	}
+}
+
+function getPropertyKey(property) {
+	if (property.computed || property.type !== "Property") {
+		return null;
+	}
+	return property.key.name ?? property.key.value ?? null;
+}
+
+function inspectLocaleTables() {
+	const localeSwitches = [];
+	const localeObjects = [];
+
+	for (const filename of sourceFiles) {
+		const source = readFileSync(filename, "utf8");
+		const ast = espree.parse(source, {
+			ecmaVersion: "latest",
+			loc: true,
+			range: true,
+			sourceType: "module",
+		});
+
+		walk(ast, (node) => {
+			if (node.type === "SwitchStatement") {
+				const discriminant = source.slice(
+					node.discriminant.start,
+					node.discriminant.end,
+				);
+				if (!/\.language\b/.test(discriminant)) {
+					return;
+				}
+
+				localeSwitches.push({
+					filename,
+					line: node.loc.start.line,
+					codes: node.cases
+						.map((entry) => entry.test?.value)
+						.filter((entry) => typeof entry === "string"),
+					hasDefault: node.cases.some((entry) => entry.test === null),
+				});
+			}
+
+			if (node.type === "ObjectExpression") {
+				const keys = node.properties
+					.map((property) => getPropertyKey(property))
+					.filter((key) => typeof key === "string");
+				const supportedKeys = keys.filter((key) =>
+					currentSupportedLanguages.includes(key),
+				);
+				if (supportedKeys.length >= 5) {
+					localeObjects.push({
+						filename,
+						line: node.loc.start.line,
+						keys,
+					});
+				}
+			}
+		});
+	}
+
+	return { localeSwitches, localeObjects };
+}
+
+describe("built-in locale coverage", () => {
+	const { localeSwitches, localeObjects } = inspectLocaleTables();
+
+	it("keeps the supported locale list unique", () => {
+		expect(new Set(currentSupportedLanguages).size).to.equal(
+			currentSupportedLanguages.length,
+		);
+	});
+
+	it("covers every supported locale in language switches", () => {
+		expect(localeSwitches.length).to.be.greaterThan(30);
+
+		for (const table of localeSwitches) {
+			const location = `${table.filename}:${table.line}`;
+			for (const language of currentSupportedLanguages) {
+				if (language === "en" && table.hasDefault) {
+					continue;
+				}
+				expect(table.codes, `${location} is missing ${language}`).to.include(
+					language,
+				);
+			}
+			expect(
+				table.codes,
+				`${location} uses an obsolete Spanish code`,
+			).not.to.include("sp");
+			expect(
+				table.codes,
+				`${location} uses an obsolete Danish code`,
+			).not.to.include("dk");
+			expect(
+				table.codes,
+				`${location} uses an obsolete Swedish code`,
+			).not.to.include("sw");
+		}
+	});
+
+	it("covers every supported locale in language maps", () => {
+		expect(localeObjects.length).to.be.greaterThan(3);
+
+		for (const table of localeObjects) {
+			const location = `${table.filename}:${table.line}`;
+			for (const language of currentSupportedLanguages) {
+				expect(table.keys, `${location} is missing ${language}`).to.include(
+					language,
+				);
+			}
+		}
+	});
+});

package/test/cases/i18n/time-ago.mjs

@@ -1,33 +1,53 @@
-
-
-import {expect} from "chai"
-import {formatTimeAgo} from "../../../source/i18n/time-ago.mjs";
-
-describe('formatTimeAgo', () => {
-    it('returns "just now" for times less than a second ago', () => {
-        const now = new Date();
-        expect(formatTimeAgo(now, 'en')).to.equal('just now');
-    });
-
-    it('returns "in 1 second" for one second in the future', () => {
-        const oneSecondFuture = new Date(Date.now() + 1000);
-        expect(formatTimeAgo(oneSecondFuture, 'en')).to.equal('in 1 second');
-    });
-
-    it('returns "1 second ago" for one second in the past', () => {
-        const oneSecondPast = new Date(Date.now() - 1000);
-        expect(formatTimeAgo(oneSecondPast, 'en')).to.equal('1 second ago');
-    });
-
-    it('returns "in 1 minute, 30 seconds" for 90 seconds in the future', () => {
-        const ninetySecondsFuture = new Date(Date.now() + 90000);
-        expect(formatTimeAgo(ninetySecondsFuture, 'en')).to.equal('in 1 minute and 30 seconds');
-    });
-
-    it('returns "1 minute, 30 seconds ago" for 90 seconds in the past', () => {
-        const ninetySecondsPast = new Date(Date.now() - 90000);
-        expect(formatTimeAgo(ninetySecondsPast, 'en')).to.equal('1 minute and 30 seconds ago');
-    });
-
-    // Weitere Tests können hinzugefügt werden
+import { expect } from "chai";
+import { currentSupportedLanguages } from "../../../source/i18n/map/languages.mjs";
+import { formatTimeAgo } from "../../../source/i18n/time-ago.mjs";
+
+describe("formatTimeAgo", () => {
+	it('returns "just now" for times less than a second ago', () => {
+		const now = new Date();
+		expect(formatTimeAgo(now, "en")).to.equal("just now");
+	});
+
+	it('returns "in 1 second" for one second in the future', () => {
+		const oneSecondFuture = new Date(Date.now() + 1000);
+		expect(formatTimeAgo(oneSecondFuture, "en")).to.equal("in 1 second");
+	});
+
+	it('returns "1 second ago" for one second in the past', () => {
+		const oneSecondPast = new Date(Date.now() - 1000);
+		expect(formatTimeAgo(oneSecondPast, "en")).to.equal("1 second ago");
+	});
+
+	it('returns "in 1 minute, 30 seconds" for 90 seconds in the future', () => {
+		const ninetySecondsFuture = new Date(Date.now() + 90000);
+		expect(formatTimeAgo(ninetySecondsFuture, "en")).to.equal(
+			"in 1 minute and 30 seconds",
+		);
+	});
+
+	it('returns "1 minute, 30 seconds ago" for 90 seconds in the past', () => {
+		const ninetySecondsPast = new Date(Date.now() - 90000);
+		expect(formatTimeAgo(ninetySecondsPast, "en")).to.equal(
+			"1 minute and 30 seconds ago",
+		);
+	});
+
+	it("formats relative times for every supported South Asian locale", () => {
+		const oneHourFuture = new Date(Date.now() + 3600000);
+
+		expect(formatTimeAgo(oneHourFuture, "bn")).to.equal("1 ঘণ্টা পরে");
+		expect(formatTimeAgo(oneHourFuture, "pa")).to.equal("1 ਘੰਟਾ ਬਾਅਦ");
+		expect(formatTimeAgo(oneHourFuture, "mr")).to.equal("1 तास नंतर");
+	});
+
+	it("formats every supported locale without falling back to a missing table", () => {
+		const oneHourFuture = new Date(Date.now() + 3600000);
+
+		for (const locale of currentSupportedLanguages) {
+			expect(formatTimeAgo(oneHourFuture, locale), locale).to.be.a("string").and
+				.not.be.empty;
+		}
+	});
+
+	// Weitere Tests können hinzugefügt werden
 });