@schukai/monster 4.153.1 → 4.154.1

package/source/util/clone.mjs

@@ -42,6 +42,16 @@ export { clone };
  * @throws {Error} unable to clone obj! its type isn't supported.
  */
 function clone(obj) {
+	return cloneValue(obj, new WeakMap());
+}
+
+/**
+ * @private
+ * @param {*} obj
+ * @param {WeakMap} seen already cloned objects, keyed by source
+ * @return {*}
+ */
+function cloneValue(obj, seen) {
 	// typeof null results in 'object'.  https://2ality.com/2013/10/typeof-null.html
 	if (null === obj) {
 		return obj;
@@ -59,9 +69,14 @@ function clone(obj) {
 
 	// Handle Array
 	if (isArray(obj)) {
+		if (seen.has(obj)) {
+			return seen.get(obj);
+		}
+
 		const copy = [];
+		seen.set(obj, copy);
 		for (let i = 0, len = obj.length; i < len; i++) {
-			copy[i] = clone(obj[i]);
+			copy[i] = cloneValue(obj[i], seen);
 		}
 
 		return copy;
@@ -87,18 +102,28 @@ function clone(obj) {
 
 		// Handle Map
 		if (obj instanceof Map) {
+			if (seen.has(obj)) {
+				return seen.get(obj);
+			}
+
 			const copy = new Map();
+			seen.set(obj, copy);
 			for (const [key, value] of obj.entries()) {
-				copy.set(clone(key), clone(value));
+				copy.set(cloneValue(key, seen), cloneValue(value, seen));
 			}
 			return copy;
 		}
 
 		// Handle Set
 		if (obj instanceof Set) {
+			if (seen.has(obj)) {
+				return seen.get(obj);
+			}
+
 			const copy = new Set();
+			seen.set(obj, copy);
 			for (const value of obj.values()) {
-				copy.add(clone(value));
+				copy.add(cloneValue(value, seen));
 			}
 			return copy;
 		}
@@ -119,7 +144,7 @@ function clone(obj) {
 		if (typeof navigator !== "undefined" && obj === navigator) return obj;
 		if (typeof JSON !== "undefined" && obj === JSON) return obj;
 		if (isProxy(obj)) return obj; // Handle Proxy-Object
-		return cloneObject(obj);
+		return cloneObject(obj, seen);
 	}
 
 	throw new Error("unable to clone obj! its type isn't supported.");
@@ -128,12 +153,17 @@ function clone(obj) {
 /**
  *
  * @param {object} obj
+ * @param {WeakMap} seen already cloned objects, keyed by source
  * @return {object}
  * @private
  */
-function cloneObject(obj) {
+function cloneObject(obj, seen) {
 	validateObject(obj);
 
+	if (seen.has(obj)) {
+		return seen.get(obj);
+	}
+
 	const fkt = obj?.["constructor"];
 	const sourcePrototype = Object.getPrototypeOf(obj);
 
@@ -145,19 +175,19 @@ function cloneObject(obj) {
 				Object.prototype.hasOwnProperty.call(prototype, "getClone") &&
 				typeOf(obj.getClone) === "function"
 			) {
+				// deliberately before the memo is written: the object decides for
+				// itself what its copy is, and that result must not be replaced by
+				// a half built copy when the object is reached again inside a cycle.
 				return obj.getClone();
 			}
 		}
 	}
 
-	let copy = sourcePrototype === null ? Object.create(null) : {};
-	if (
-		sourcePrototype !== null &&
-		typeof fkt === "function" &&
-		typeof fkt.call === "function"
-	) {
-		copy = new fkt();
-	}
+	// The constructor is not invoked. Calling it would run arbitrary code and
+	// fail for every class whose constructor requires arguments. Classes that
+	// need constructor work expose getClone() instead.
+	const copy = Object.create(sourcePrototype);
+	seen.set(obj, copy);
 
 	for (const key in obj) {
 		if (!Object.prototype.hasOwnProperty.call(obj, key)) {
@@ -169,7 +199,7 @@ function cloneObject(obj) {
 			continue;
 		}
 
-		copy[key] = clone(obj[key]);
+		copy[key] = cloneValue(obj[key], seen);
 	}
 
 	return copy;

package/test/cases/browser-bundle.mjs

@@ -0,0 +1,75 @@
+"use strict";
+
+import { expect } from "chai";
+import { buildCurrentTests } from "../web/current-bundle.mjs";
+
+/**
+ * Guards the browser test bundle for issue #577.
+ *
+ * The browser tier bundles the cases as bare `import "<file>"` statements. A
+ * `sideEffects` list in package.json is a restriction: every path it does not
+ * match counts as side effect free, and esbuild then drops those bare imports.
+ * With `./test/**` missing from the list the bundle collapsed from about 9 MB
+ * to 15 bytes, and all three browser jobs reported `0 passing, 0 failing,
+ * 0 pending` rather than failing loudly.
+ *
+ * This file runs esbuild over the repository, so it is listed in nodeOnlyCases
+ * in test/web/current-bundle.mjs and does not run in the browser bundle itself.
+ */
+describe("Browser test bundle issue #577", function () {
+	this.timeout(60000);
+
+	let bundle;
+
+	before(async function () {
+		bundle = await buildCurrentTests();
+	});
+
+	it("should collect the case files", function () {
+		expect(bundle.files).to.be.an("array");
+		expect(
+			bundle.files.length,
+			"far fewer case files than the repository contains",
+		).to.be.above(150);
+	});
+
+	it("should produce a bundle that actually contains the cases", function () {
+		// an emptied bundle is a few bytes, a complete one is megabytes
+		expect(
+			bundle.code.length,
+			"the bundled browser suite is far too small to hold the test cases",
+		).to.be.above(1_000_000);
+	});
+
+	it("should keep the suites of the bundled files", function () {
+		// every case file registers suites at module scope, so dropping the bare
+		// imports removes these calls even though the file list stays complete
+		const suites = [...bundle.code.matchAll(/\bdescribe\(/g)].length;
+
+		expect(suites, "the bundle registers almost no suites").to.be.above(300);
+	});
+
+	it("should contain content from several distinct case files", function () {
+		for (const marker of [
+			"Pathfinder resolution baseline",
+			"CustomElement rebind baseline",
+			"Updater remove attribute",
+			"MonthCalendar date configuration",
+			"contains all tokens",
+		]) {
+			expect(
+				bundle.code.includes(marker),
+				`the bundle does not contain "${marker}", so cases are missing`,
+			).to.be.true;
+		}
+	});
+
+	it("should not bundle the node only cases", function () {
+		for (const nodeOnly of ["packaging.mjs", "browser-bundle.mjs"]) {
+			expect(
+				bundle.files.some((file) => file.endsWith(`test/cases/${nodeOnly}`)),
+				`${nodeOnly} must stay out of the browser bundle`,
+			).to.be.false;
+		}
+	});
+});

package/test/cases/components/datatable/drag-scroll.mjs

@@ -6,6 +6,25 @@ import { ResizeObserverMock } from "../../../util/resize-observer.mjs";
 const expect = chai.expect;
 chai.use(chaiDom);
 
+/**
+ * Waits for a value to appear instead of for a fixed delay.
+ *
+ * The components under test attach their ResizeObserver inside a
+ * requestAnimationFrame, so the precondition is a frame, not a number of
+ * milliseconds. A headless browser without a compositor schedules frames less
+ * regularly, which is why a fixed 30ms wait failed in CI webkit while passing
+ * everywhere else. The deadline keeps a genuine absence failing.
+ */
+async function waitForValue(produce, timeout = 2000, interval = 10) {
+	const deadline = Date.now() + timeout;
+	for (;;) {
+		const value = produce();
+		if (value !== undefined && value !== null) return value;
+		if (Date.now() >= deadline) return value;
+		await new Promise((resolve) => setTimeout(resolve, interval));
+	}
+}
+
 // Supply geometry before the first layout can populate the measurement cache.
 function installColumnBarGeometry(parentWidth) {
 	const original = HTMLElement.prototype.getBoundingClientRect;
@@ -434,10 +453,13 @@ describe("Datatable drag scroll", function () {
 			);
 			expect(control).to.exist;
 			expect(control.classList.contains("small")).to.equal(false);
-			expect(TrackingResizeObserver.instances).to.have.length.greaterThan(0);
-			const tableResizeObserver = TrackingResizeObserver.instances.find(
-				(observer) => observer.elements.includes(wrapper),
+			const tableResizeObserver = await waitForValue(() =>
+				TrackingResizeObserver.instances.find((observer) =>
+					observer.elements.includes(wrapper),
+				),
 			);
+
+			expect(TrackingResizeObserver.instances).to.have.length.greaterThan(0);
 			expect(tableResizeObserver).to.exist;
 
 			let scheduledCallback = null;
@@ -456,6 +478,10 @@ describe("Datatable drag scroll", function () {
 			scheduledCallback();
 
 			expect(control.classList.contains("small")).to.equal(true);
+
+			// The responsive layout stays in the document otherwise, and the
+			// browser keeps rendering it for the rest of the run.
+			wrapper.remove();
 		} finally {
 			window.ResizeObserver = OriginalResizeObserver;
 			globalThis.ResizeObserver = originalGlobalResizeObserver;
@@ -546,8 +572,10 @@ describe("Datatable drag scroll", function () {
 				dotsContainer.querySelector(".dots-overflow-indicator"),
 			).to.equal(null);
 
-			const columnBarResizeObserver = TrackingResizeObserver.instances.find(
-				(observer) => observer.elements.includes(control),
+			const columnBarResizeObserver = await waitForValue(() =>
+				TrackingResizeObserver.instances.find((observer) =>
+					observer.elements.includes(control),
+				),
 			);
 			expect(columnBarResizeObserver).to.exist;
 
@@ -660,11 +688,15 @@ describe("Datatable drag scroll", function () {
 			const first = await createColumnBar();
 			const second = await createColumnBar();
 
-			const firstResizeObserver = TrackingResizeObserver.instances.find(
-				(observer) => observer.elements.includes(first.control),
+			const firstResizeObserver = await waitForValue(() =>
+				TrackingResizeObserver.instances.find((observer) =>
+					observer.elements.includes(first.control),
+				),
 			);
-			const secondResizeObserver = TrackingResizeObserver.instances.find(
-				(observer) => observer.elements.includes(second.control),
+			const secondResizeObserver = await waitForValue(() =>
+				TrackingResizeObserver.instances.find((observer) =>
+					observer.elements.includes(second.control),
+				),
 			);
 
 			expect(firstResizeObserver).to.exist;

package/test/cases/components/navigation/site-navigation.mjs

@@ -77,7 +77,16 @@ describe("SiteNavigation", function () {
 			resizeObserver.triggerResize([]);
 			resizeObserver.triggerResize([]);
 
-			await new Promise(resolve => setTimeout(resolve, 260));
+			// The component debounces resizes with a 200ms DeadMansSwitch and then
+			// requests exactly one frame. Waiting 260ms left 60ms of margin over
+			// that debounce, which is not enough under software rendering: the run
+			// then measured zero scheduled frames. Waiting for the first request
+			// keeps the coalescing assertion strict without assuming wall clock.
+			const deadline = Date.now() + 5000;
+			while (scheduledCallbacks.length === 0 && Date.now() < deadline) {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+			}
+
 			expect(scheduledCallbacks.length).to.equal(1);
 			scheduledCallbacks.shift()();
 		} finally {

package/test/cases/components/time/month-calendar.mjs

@@ -70,6 +70,121 @@ describe("MonthCalendar date configuration", () => {
 		expect(currentDays(calendar)[0].month).to.equal(new Date().getMonth() + 1);
 		expect(calendar.getOption("calendarDays")).to.have.length(42);
 	});
+	describe("document language issue #578", () => {
+		// The oracle is Intl itself with an explicit tag, so none of these
+		// assertions depend on the locale of the machine running the suite.
+		const MONDAY = new Date(1970, 0, 5);
+		const weekdayIn = (tag, format) =>
+			new Intl.DateTimeFormat(tag, { weekday: format }).format(MONDAY);
+
+		let originalLang;
+
+		beforeEach(() => {
+			originalLang = document.documentElement.getAttribute("lang");
+		});
+
+		afterEach(() => {
+			if (originalLang === null) {
+				document.documentElement.removeAttribute("lang");
+			} else {
+				document.documentElement.setAttribute("lang", originalLang);
+			}
+		});
+
+		async function calendarFor(lang, format = "long") {
+			document.documentElement.setAttribute("lang", lang);
+			const calendar = document.createElement("monster-month-calendar");
+			calendar.setOption("startDate", "2026-10-01");
+			document.getElementById("mocks").append(calendar);
+			await updates();
+			calendar.setOption("locale.weekdayFormat", format);
+			await updates();
+			return calendar;
+		}
+
+		// net: the weekday header is always seven entries, indexed Monday first,
+		// and every label is a non empty string
+		it("produces seven indexed weekdays", async () => {
+			const calendar = await calendarFor("en");
+			const weekdays = calendar.getOption("calendarWeekdays");
+
+			expect(weekdays).to.have.length(7);
+			expect(weekdays.map((entry) => entry.index)).to.deep.equal([
+				0, 1, 2, 3, 4, 5, 6,
+			]);
+			for (const entry of weekdays) {
+				expect(entry.label).to.be.a("string").and.to.have.length.above(0);
+			}
+		});
+
+		it("rejects an invalid weekday format and falls back to short", async () => {
+			const calendar = await calendarFor("en", "bogus");
+			const weekdays = calendar.getOption("calendarWeekdays");
+
+			expect(calendar.hasAttribute(ATTRIBUTE_ERRORMESSAGE)).to.be.true;
+			// the short form is shorter than the long one, whatever the language
+			expect(weekdays[0].label.length).to.be.below(
+				weekdayIn("en", "long").length,
+			);
+		});
+
+		// net: this path reads locale.language, a string, and already works
+		it("translates the more-appointments label from the document language", async () => {
+			const calendar = await calendarFor("de");
+			const cell = calendar.shadowRoot.querySelector(
+				'[data-monster-day="2026-10-01"]',
+			);
+
+			expect(
+				cell.querySelector('[data-monster-role="more-appointments"]')
+					.textContent,
+			).to.contain("Weitere Termine");
+		});
+
+		// regression: Intl received the Locale instance instead of its tag, so the
+		// document language was ignored and the host system locale decided. At
+		// most one of these languages can match the machine locale, so the set is
+		// red before the fix in any environment.
+		for (const lang of ["ja", "de", "en", "es"]) {
+			it(`formats weekday names for lang="${lang}"`, async () => {
+				const calendar = await calendarFor(lang);
+
+				expect(calendar.getOption("calendarWeekdays")[0].label).to.equal(
+					weekdayIn(lang, "long"),
+				);
+			});
+		}
+
+		it("changes weekday names when the document language changes", async () => {
+			const japanese = await calendarFor("ja");
+			const japaneseLabel = japanese.getOption("calendarWeekdays")[0].label;
+
+			const spanish = await calendarFor("es");
+			const spanishLabel = spanish.getOption("calendarWeekdays")[0].label;
+
+			expect(japaneseLabel).to.equal(weekdayIn("ja", "long"));
+			expect(spanishLabel).to.equal(weekdayIn("es", "long"));
+			expect(japaneseLabel).to.not.equal(spanishLabel);
+		});
+
+		it("falls back to the short format in the document language", async () => {
+			const calendar = await calendarFor("ja", "bogus");
+
+			expect(calendar.hasAttribute(ATTRIBUTE_ERRORMESSAGE)).to.be.true;
+			expect(calendar.getOption("calendarWeekdays")[0].label).to.equal(
+				weekdayIn("ja", "short"),
+			);
+		});
+
+		it("honors the document language for the short format as well", async () => {
+			const calendar = await calendarFor("ja", "short");
+
+			expect(calendar.getOption("calendarWeekdays")[0].label).to.equal(
+				weekdayIn("ja", "short"),
+			);
+		});
+	});
+
 	it("keeps day interactions and weekday updates working after changing months", async () => {
 		const calendar = document.createElement("monster-month-calendar");
 		document.getElementById("mocks").append(calendar);

package/test/cases/data/diff.mjs

@@ -285,4 +285,90 @@ describe('Diff', function () {
 
     });
 
+    describe('numeric identity issue #571', function () {
+
+        // net: these describe behaviour that is already correct today
+        it('should report an update when NaN is replaced by a number', function () {
+            let d = diff({a: NaN}, {a: 1});
+            expect(d.length).is.equal(1);
+            expect(d[0].operator).is.equal('update');
+            expect(d[0].path).is.eql(['a']);
+        });
+
+        it('should report an update when a number is replaced by NaN', function () {
+            let d = diff({a: 1}, {a: NaN});
+            expect(d.length).is.equal(1);
+            expect(d[0].operator).is.equal('update');
+            expect(d[0].path).is.eql(['a']);
+        });
+
+        it('should keep treating 0 and -0 as equal', function () {
+            expect(JSON.stringify(diff({a: 0}, {a: -0}))).is.equal('[]');
+            expect(JSON.stringify(diff({a: -0}, {a: 0}))).is.equal('[]');
+        });
+
+        // regression: two equal NaN values are not a change
+        it('should not report a change for two NaN values at the same path', function () {
+            expect(JSON.stringify(diff({a: NaN}, {a: NaN}))).is.equal('[]');
+        });
+
+        it('should not report a change for nested NaN values', function () {
+            let first = {a: {b: NaN}, c: {d: {e: NaN}}};
+            let second = {a: {b: NaN}, c: {d: {e: NaN}}};
+            expect(JSON.stringify(diff(first, second))).is.equal('[]');
+        });
+
+        it('should not report a change for NaN inside an unchanged array', function () {
+            expect(JSON.stringify(diff([NaN, 1], [NaN, 1]))).is.equal('[]');
+        });
+
+        it('should not report a change for a NaN value reached through a wildcard shaped tree', function () {
+            let first = {rows: [{value: NaN}, {value: 2}]};
+            let second = {rows: [{value: NaN}, {value: 2}]};
+            expect(JSON.stringify(diff(first, second))).is.equal('[]');
+        });
+    })
+
+    describe('array key handling issue #574', function () {
+
+        // net: array indices are reported as string path segments. getKeys() has a
+        // dead numeric-index branch; replacing it would turn ["0"] into [0] and
+        // change every array diff path, so these pin the contract first.
+        it('should report deletions with string index paths when an array shrinks', function () {
+            let d = diff({a: [1, 2, 3]}, {a: [1]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"delete","path":["a","1"],"first":{"value":2,"type":"number"}},{"operator":"delete","path":["a","2"],"first":{"value":3,"type":"number"}}]');
+        });
+
+        it('should report additions with string index paths when an array grows', function () {
+            let d = diff({a: [1]}, {a: [1, 2]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"add","path":["a","1"],"second":{"value":2,"type":"number"}}]');
+        });
+
+        it('should report an update with a string index path when an element changes', function () {
+            let d = diff({a: [1, 2]}, {a: [1, 9]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"update","path":["a","1"],"first":{"value":2,"type":"number"},"second":{"value":9,"type":"number"}}]');
+        });
+
+        it('should report no change for identical arrays', function () {
+            expect(JSON.stringify(diff({a: [1, 2, 3]}, {a: [1, 2, 3]}))).is.equal('[]');
+        });
+
+        it('should diff nested arrays of objects with string index paths', function () {
+            let d = diff({rows: [{id: 1}, {id: 2}]}, {rows: [{id: 1}, {id: 3}]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"update","path":["rows","1","id"],"first":{"value":2,"type":"number"},"second":{"value":3,"type":"number"}}]');
+        });
+
+        it('should treat a sparse array hole as absent rather than as undefined', function () {
+            let sparse = [1];
+            sparse[2] = 3;
+
+            expect(JSON.stringify(diff({a: sparse}, {a: sparse}))).is.equal('[]');
+            expect(Object.hasOwn(sparse, '1')).to.be.false;
+        });
+    })
+
 })

package/test/cases/data/extend.mjs

@@ -183,6 +183,58 @@ describe('extend function', () => {
             }
         });
     });
+
+    // net: behaviour that is already correct and must stay correct
+    it('should keep merging nested objects without losing existing keys issue #573', () => {
+        const target = { a: { b: 1, keep: 'yes' } };
+        const source = { a: { c: 2 } };
+
+        expect(extend(target, source)).to.deep.equal({ a: { b: 1, c: 2, keep: 'yes' } });
+    });
+
+    it('should keep throwing on a type mismatch issue #573', () => {
+        expect(() => extend({ a: { b: 1 } }, { a: [1, 2] })).to.throw();
+        expect(() => extend({ a: [1, 2] }, { a: { b: 1 } })).to.throw();
+    });
+
+    it('should keep throwing for unsupported arguments issue #573', () => {
+        expect(() => extend({ a: 1 }, 'not an object')).to.throw();
+        expect(() => extend(null, { a: 1 })).to.throw();
+    });
+
+    // regression: a cyclic source must terminate instead of exhausting the stack
+    it('should extend from a self referencing source issue #573', () => {
+        const source = { name: 'root' };
+        source.self = source;
+
+        const result = extend({}, source);
+
+        expect(result.name).to.equal('root');
+        expect(result.self).to.be.an('object');
+        expect(result.self.name).to.equal('root');
+    });
+
+    it('should extend from a mutual reference between two sources issue #573', () => {
+        const first = { name: 'first' };
+        const second = { name: 'second', first };
+        first.second = second;
+
+        const result = extend({}, first);
+
+        expect(result.name).to.equal('first');
+        expect(result.second.name).to.equal('second');
+        expect(result.second.first).to.be.an('object');
+    });
+
+    it('should extend from a cycle that runs through an array issue #573', () => {
+        const source = { items: [] };
+        source.items.push(source);
+
+        const result = extend({}, source);
+
+        expect(result.items).to.be.an('array');
+        expect(result.items.length).to.equal(1);
+    });
 });