@schukai/monster 4.154.0 → 4.154.2

package/source/util/comparator.mjs

@@ -38,17 +38,17 @@ export { Comparator };
  *      }).equal({v: 2}, {v: 2});  // ↦ true
  * ```
  *
- * @example /example/comparator/simple/ Simple example
  * @license AGPLv3
  * @since 1.3.0
+ * @summary Wraps customizable comparison operations for arbitrary values.
  */
 class Comparator extends Base {
 	/**
 	 * create new comparator
 	 *
 	 * @param {Monster.Util~exampleCallback} [callback] Comparator callback
-	 * @throw {TypeError} unsupported type
-	 * @throw {TypeError} impractical comparison
+	 * @throws {TypeError} unsupported type
+	 * @throws {TypeError} impractical comparison
 	 */
 	constructor(callback) {
 		super();

package/source/util/deadmansswitch.mjs

@@ -24,7 +24,6 @@ export { DeadMansSwitch };
  * The dead man's switch allows setting a timer which can be reset again
  * and again within a defined period of time.
  *
- * @example /example/util/deadmansswitch/simple/ Simple example
  * @copyright Volker Schukai
  * @license AGPLv3
  * @since 1.29.0
@@ -36,7 +35,7 @@ class DeadMansSwitch extends Base {
 	 *
 	 * @param {Integer} delay
 	 * @param {function} callback
-	 * @throw {TypeError} the arguments must be either integer or functions
+	 * @throws {TypeError} the arguments must be either integer or functions
 	 * @throws {TypeError} value is not an integer
 	 */
 	constructor(delay, callback) {
@@ -47,7 +46,7 @@ class DeadMansSwitch extends Base {
 
 	/**
 	 * @param delay
-	 * @returns {DeadMansSwitch}
+	 * @return {DeadMansSwitch}
 	 * @throws {Error} has already run
 	 * @throws {Error} unsupported argument
 	 */
@@ -70,7 +69,7 @@ class DeadMansSwitch extends Base {
 
 	/**
 	 * @throws {Error} has already run
-	 * @returns {DeadMansSwitch}
+	 * @return {DeadMansSwitch}
 	 */
 	defuse() {
 		if (this[internalSymbol]["isAlreadyRun"] === true) {

package/source/util/processing.mjs

@@ -54,7 +54,7 @@ class Processing extends Base {
 	 *
 	 * So the execution time is timeout1+timeout1+timeout1+timeout2
 	 *
-	 * @throw {TypeError} the arguments must be either integer or functions
+	 * @throws {TypeError} the arguments must be either integer or functions
 	 * @param {...(int|function)} args
 	 */
 	constructor(...args) {

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,16 +688,30 @@ 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;
 			expect(secondResizeObserver).to.exist;
 
+			// Drain initialization work from the module-level shared frame before
+			// replacing requestAnimationFrame. Otherwise a slow renderer can still
+			// have that frame pending and the observer updates correctly join it,
+			// leaving the spy below with no newly scheduled callback.
+			await new Promise((resolve) => {
+				window.requestAnimationFrame(() =>
+					window.requestAnimationFrame(resolve),
+				);
+			});
+
 			const scheduledCallbacks = [];
 			window.requestAnimationFrame = (callback) => {
 				scheduledCallbacks.push(callback);

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 {