@schukai/monster 4.153.1 → 4.154.1

package/test/cases/packaging.mjs

@@ -0,0 +1,213 @@
+"use strict";
+
+import { expect } from "chai";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Packaging regressions for issue #577.
+ *
+ * Two classes of mistake are guarded here. An exports map that does not cover
+ * an established import path turns a patch release into a breaking change, and
+ * a field added to package.json never reaches the npm package unless the
+ * whitelist in nix/scripts/build.nix carries it too, because the published
+ * manifest is reassembled there from scratch.
+ *
+ * This file reads the repository, so it is listed in nodeOnlyCases in
+ * test/web/current-bundle.mjs and does not run in the browser bundle.
+ */
+const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+
+function readPackageJson() {
+	return JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf8"));
+}
+
+function readBuildNix() {
+	return readFileSync(join(projectRoot, "nix/scripts/build.nix"), "utf8");
+}
+
+describe("Packaging issue #577", function () {
+	describe("exports map", function () {
+		it("should resolve every literal export target to an existing file", function () {
+			const pkg = readPackageJson();
+			expect(pkg.exports, "exports map is missing").to.be.an("object");
+
+			for (const [subpath, target] of Object.entries(pkg.exports)) {
+				if (typeof target !== "string" || target.includes("*")) {
+					continue;
+				}
+
+				const absolute = join(projectRoot, target);
+				expect(
+					existsSync(absolute),
+					`${subpath} points at a missing file: ${target}`,
+				).to.be.true;
+			}
+		});
+
+		it("should expose the package entry point", function () {
+			const pkg = readPackageJson();
+			const entry = pkg.exports["."];
+
+			expect(entry, "no entry point exported").to.not.equal(undefined);
+
+			const target = typeof entry === "string" ? entry : entry.default;
+			expect(target).to.equal(`./${pkg.main}`);
+			expect(existsSync(join(projectRoot, target))).to.be.true;
+		});
+
+		it("should keep every published top level path reachable", function () {
+			const pkg = readPackageJson();
+			const patterns = Object.keys(pkg.exports);
+
+			function covered(entry) {
+				const head = entry.split("/")[0];
+				return patterns.some(
+					(pattern) =>
+						pattern === `./${entry}` ||
+						pattern === `./${head}/*` ||
+						pattern.startsWith(`./${head}/`),
+				);
+			}
+
+			// Adding an exports map restricts what consumers may import. Anything
+			// listed in files was importable before and has to stay importable.
+			for (const entry of pkg.files) {
+				expect(covered(entry), `files entry "${entry}" is not covered by exports`)
+					.to.be.true;
+			}
+
+			// npm publishes these regardless of files, so they were reachable too
+			for (const entry of ["README.md", "LICENSE"]) {
+				expect(
+					covered(entry),
+					`"${entry}" ships in the package but is not covered by exports`,
+				).to.be.true;
+			}
+		});
+
+		it("should resolve established deep import paths through the patterns", function () {
+			const pkg = readPackageJson();
+
+			const established = [
+				"source/monster.mjs",
+				"source/dom/customelement.mjs",
+				"source/dom/updater.mjs",
+				"source/data/pathfinder.mjs",
+				"source/types/tokenlist.mjs",
+				"source/util/clone.mjs",
+				"source/components/form/select.mjs",
+				"test/util/jsdom.mjs",
+			];
+
+			for (const path of established) {
+				const head = path.split("/")[0];
+				const pattern = pkg.exports[`./${head}/*`];
+
+				expect(pattern, `no pattern export for ./${head}/*`).to.be.a("string");
+
+				const target = pattern.replace("*", path.slice(head.length + 1));
+				expect(
+					existsSync(join(projectRoot, target)),
+					`${path} does not resolve through ${pattern}`,
+				).to.be.true;
+			}
+		});
+	});
+
+	describe("side effect metadata", function () {
+		it("should not mark component modules as side effect free", function () {
+			const pkg = readPackageJson();
+
+			expect(pkg.sideEffects, "sideEffects is missing").to.be.an("array");
+
+			// every component module calls registerCustomElement() at module scope,
+			// so a bundler must never drop one
+			const covered = pkg.sideEffects.some(
+				(pattern) =>
+					pattern === "./source/components/**" ||
+					pattern === "./source/**" ||
+					pattern === "./source/components/*",
+			);
+
+			expect(covered, "component modules are not declared side effectful").to.be
+				.true;
+			expect(pkg.sideEffects).to.include("./source/monster.mjs");
+		});
+	});
+
+	describe("published manifest", function () {
+		it("should carry every publish relevant field into the build whitelist", function () {
+			const pkg = readPackageJson();
+			const buildNix = readBuildNix();
+
+			// fields that only matter for development stay out of the package
+			const developmentOnly = new Set([
+				"devDependencies",
+				"main",
+				"module",
+				"type",
+			]);
+
+			for (const field of Object.keys(pkg)) {
+				if (developmentOnly.has(field)) {
+					continue;
+				}
+
+				expect(
+					buildNix.includes(`${field} =`),
+					`package.json field "${field}" is missing from releasedPackageJson in nix/scripts/build.nix, so it never reaches the npm package`,
+				).to.be.true;
+			}
+		});
+	});
+
+	describe("generated barrel", function () {
+		it("should export the core symbols", function () {
+			const barrel = readFileSync(
+				join(projectRoot, "source/monster.mjs"),
+				"utf8",
+			);
+
+			const core = [
+				"./dom/customelement.mjs",
+				"./dom/customcontrol.mjs",
+				"./dom/updater.mjs",
+				"./data/pathfinder.mjs",
+				"./data/diff.mjs",
+				"./data/extend.mjs",
+				"./types/base.mjs",
+				"./types/proxyobserver.mjs",
+				"./types/observer.mjs",
+				"./types/tokenlist.mjs",
+				"./util/clone.mjs",
+			];
+
+			for (const module of core) {
+				expect(
+					barrel.includes(`from "${module}"`),
+					`the generated barrel no longer re-exports ${module}`,
+				).to.be.true;
+			}
+		});
+
+		it("should reference only existing modules", function () {
+			const barrel = readFileSync(
+				join(projectRoot, "source/monster.mjs"),
+				"utf8",
+			);
+
+			const matches = [...barrel.matchAll(/from "(\.\/[^"]+)"/g)];
+			expect(matches.length).to.be.greaterThan(100);
+
+			for (const match of matches) {
+				const target = join(projectRoot, "source", match[1]);
+				expect(
+					existsSync(target) && statSync(target).isFile(),
+					`the barrel references a missing module: ${match[1]}`,
+				).to.be.true;
+			}
+		});
+	});
+});

package/test/cases/types/base.mjs

@@ -25,6 +25,26 @@ class Subclass extends BaseDifferentRealm {
     }
 }
 
+// an own instanceSymbol whose getter yields undefined, which is the only way to
+// reach the traversal branch that lost its receiver, see issue #574
+class UndefinedSymbolBelowBase extends Base {
+    static get [instanceSymbol]() {
+        return undefined;
+    }
+}
+
+class UnrelatedWithUndefinedSymbol extends Object {
+    static get [instanceSymbol]() {
+        return undefined;
+    }
+}
+
+class DeepUndefinedSymbol extends UndefinedSymbolBelowBase {
+    static get [instanceSymbol]() {
+        return undefined;
+    }
+}
+
 describe('Base', function () {
 
     describe('new Base', function () {
@@ -60,4 +80,34 @@ describe('Base', function () {
 
     })
 
+    describe('instance symbol traversal issue #574', function () {
+
+        // net: traversal results that are already correct
+        it('should keep reporting a subclass with its own symbol as an instance', function () {
+            expect(new Subclass).to.be.instanceOf(Base);
+        });
+
+        it('should not report a plain object or a foreign class as an instance', function () {
+            expect({}).to.not.be.instanceOf(Base);
+            expect(new (class Foreign {})).to.not.be.instanceOf(Base);
+        });
+
+        // regression: the branch for an undefined symbol dropped its receiver, so
+        // `this.hasOwnProperty` threw a TypeError in strict mode module code
+        it('should not throw when a class in the chain yields an undefined symbol', function () {
+            expect(() => new UndefinedSymbolBelowBase instanceof Base).to.not.throw();
+            expect(() => new UnrelatedWithUndefinedSymbol instanceof Base).to.not.throw();
+        });
+
+        it('should keep walking the chain past an undefined symbol', function () {
+            expect(new UndefinedSymbolBelowBase).to.be.instanceOf(Base);
+            expect(new DeepUndefinedSymbol).to.be.instanceOf(Base);
+        });
+
+        it('should still report false for an unrelated class with an undefined symbol', function () {
+            expect(new UnrelatedWithUndefinedSymbol).to.not.be.instanceOf(Base);
+        });
+
+    })
+
 })

package/test/cases/types/observerlist.mjs

@@ -103,5 +103,107 @@ describe('ObserverList', function () {
     });
 
 
-});
+    describe('.detach() removes every occurrence issue #572', function () {
+
+        // net: behaviour that is already correct and must stay correct
+        it('should remove a single attached observer', function () {
+            let observerList = new ObserverList()
+            let o = new Observer(() => {
+            })
+
+            observerList.attach(o)
+            expect(observerList.contains(o)).to.be.true;
+
+            observerList.detach(o)
+            expect(observerList.contains(o)).to.be.false;
+            expect(observerList.observers.length).to.equal(0);
+        });
+
+        it('should keep other observers when one is detached', function () {
+            let observerList = new ObserverList()
+            let o1 = new Observer(() => {
+            })
+            let o2 = new Observer(() => {
+            })
+
+            observerList.attach(o1).attach(o2)
+            observerList.detach(o1)
+
+            expect(observerList.contains(o1)).to.be.false;
+            expect(observerList.contains(o2)).to.be.true;
+            expect(observerList.observers.length).to.equal(1);
+        });
+
+        it('should ignore detaching an observer that was never attached', function () {
+            let observerList = new ObserverList()
+            let attached = new Observer(() => {
+            })
+            let foreign = new Observer(() => {
+            })
+
+            observerList.attach(attached)
+            observerList.detach(foreign)
+
+            expect(observerList.contains(attached)).to.be.true;
+            expect(observerList.observers.length).to.equal(1);
+        });
 
+        it('should remove every occurrence when the duplicates are not adjacent', function () {
+            let observerList = new ObserverList()
+            let target = new Observer(() => {
+            })
+            let other = new Observer(() => {
+            })
+
+            observerList.attach(target).attach(other).attach(target)
+            expect(observerList.observers.length).to.equal(3);
+
+            observerList.detach(target)
+
+            expect(observerList.contains(target)).to.be.false;
+            expect(observerList.contains(other)).to.be.true;
+            expect(observerList.observers.length).to.equal(1);
+        });
+
+        // regression: forward splicing with a cached length skips the entry that
+        // moves into the freed slot, so adjacent duplicates survive detaching
+        it('should remove a doubly attached observer completely', function () {
+            let observerList = new ObserverList()
+            let o = new Observer(() => {
+            })
+
+            observerList.attach(o).attach(o)
+            expect(observerList.observers.length).to.equal(2);
+
+            observerList.detach(o)
+
+            expect(observerList.contains(o)).to.be.false;
+            expect(observerList.observers.length).to.equal(0);
+        });
+
+        it('should stop notifying a doubly attached observer after detaching', function (done) {
+            let observerList = new ObserverList()
+            let calls = 0
+            let o = new Observer(() => {
+                calls++
+            })
+
+            observerList.attach(o).attach(o)
+            observerList.detach(o)
+
+            observerList.notify({}).then(() => {
+                setTimeout(() => {
+                    try {
+                        expect(calls).to.equal(0);
+                        done();
+                    } catch (e) {
+                        done(e);
+                    }
+                }, 10);
+            }).catch(done);
+        });
+
+    });
+
+
+});

package/test/cases/types/proxyobserver.mjs

@@ -419,4 +419,118 @@ describe('ProxyObserver', function () {
         });
     });
 
+    describe('numeric identity issue #571', function () {
+
+        // net: assigning an unchanged primitive must not notify, a changed one must
+        it('should not notify when an identical number is assigned', async function () {
+            const proxy = new ProxyObserver({a: 1});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().a = 1;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(0);
+        });
+
+        it('should notify once when a number actually changes', async function () {
+            const proxy = new ProxyObserver({a: 1});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().a = 2;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(1);
+            expect(proxy.getRealSubject().a).to.equal(2);
+        });
+
+        it('should keep notifying when NaN is replaced by a number', async function () {
+            const proxy = new ProxyObserver({a: NaN});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().a = 5;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(1);
+            expect(proxy.getRealSubject().a).to.equal(5);
+        });
+
+        it('should keep notifying when a number is replaced by NaN', async function () {
+            const proxy = new ProxyObserver({a: 5});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().a = NaN;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(1);
+            expect(Number.isNaN(proxy.getRealSubject().a)).to.be.true;
+        });
+
+        // regression: an identical NaN is not a change
+        it('should not notify when an identical NaN is assigned', async function () {
+            const proxy = new ProxyObserver({a: NaN});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().a = NaN;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(0);
+        });
+
+        it('should not notify when an identical NaN is assigned on a nested path', async function () {
+            const proxy = new ProxyObserver({options: {size: NaN}});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().options.size = NaN;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(0);
+        });
+
+        it('should not notify when an identical NaN is assigned to an array entry', async function () {
+            const proxy = new ProxyObserver({values: [NaN, 1]});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().values[0] = NaN;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(0);
+        });
+
+        it('should not notify repeatedly when the same NaN is written many times', async function () {
+            const proxy = new ProxyObserver({a: NaN});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            for (let i = 0; i < 5; i++) {
+                proxy.getSubject().a = NaN;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(0);
+        });
+    });
+
 })

package/test/cases/types/regex.mjs

@@ -8,6 +8,10 @@ describe('escapeString', function () {
 
     before(function (done) {
 
+        // A cold ESM load of the library plus the jsdom bootstrap can exceed the
+        // 2000ms default, which made this hook fail depending on file order.
+        this.timeout(20000);
+
         let promises = []
         promises.push(initJSDOM());
         if(!globalThis['crypto']) {

package/test/cases/types/tokenlist.mjs

@@ -257,5 +257,68 @@ describe('TokenList', function () {
     });
 
 
-});
+    describe('contains all tokens issue #572', function () {
+
+        // net: behaviour that is already correct and must stay correct
+        it('should contain a multi token string when every token is present', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains('start middle')).to.be.true;
+            expect(list.contains('start middle end')).to.be.true;
+            expect(list.contains('end start')).to.be.true;
+        });
+
+        it('should ignore surrounding and repeated whitespace', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains('  start   middle  ')).to.be.true;
+            expect(list.contains(' end ')).to.be.true;
+        });
+
+        it('should not contain an empty or whitespace only value', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains('')).to.be.false;
+            expect(list.contains('   ')).to.be.false;
+            expect(list.contains([])).to.be.false;
+        });
+
+        it('should keep the iterable branch requiring every token', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains(['start', 'middle'])).to.be.true;
+            expect(list.contains(['start', 'xyz'])).to.be.false;
+        });
+
+        // regression: a multi token string needs every token, not just one
+        it('should not contain a multi token string when one token is missing', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains('start xyz')).to.be.false;
+        });
 
+        it('should not contain a multi token string when the missing token comes first', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains('xyz start')).to.be.false;
+        });
+
+        it('should not contain a multi token string when only two of three tokens match', function () {
+            let list = new TokenList("start middle end");
+            expect(list.contains('start middle xyz')).to.be.false;
+        });
+
+        it('should answer identically for a string and the equivalent array', function () {
+            let list = new TokenList("start middle end");
+            let cases = [
+                ['start middle', ['start', 'middle']],
+                ['start xyz', ['start', 'xyz']],
+                ['xyz abc', ['xyz', 'abc']],
+                ['end', ['end']],
+            ];
+
+            for (let [asString, asArray] of cases) {
+                expect(list.contains(asString)).to.equal(
+                    list.contains(asArray),
+                    'mismatch for ' + JSON.stringify(asString),
+                );
+            }
+        });
+    });
+
+
+});