@schukai/monster 4.153.0 → 4.154.0

package/test/cases/dom/updater-remove.mjs

@@ -0,0 +1,198 @@
+"use strict";
+
+import * as chai from "chai";
+import { getDocument } from "../../../source/dom/util.mjs";
+import { chaiDom } from "../../util/chai-dom.mjs";
+import { initJSDOM } from "../../util/jsdom.mjs";
+
+let expect = chai.expect;
+chai.use(chaiDom);
+
+/**
+ * Regressions for issue #579.
+ *
+ * data-monster-remove had no coverage anywhere in the repository, and its
+ * selector relied on a :scope prefix that carries no meaning for a descendant
+ * query but does not resolve for shadow root content under jsdom.
+ */
+describe("Updater remove attribute issue #579", function () {
+	let Updater;
+	let CustomElement;
+	let registerCustomElement;
+	let document;
+
+	const html = `
+    <div id="test1"></div>
+`;
+
+	before(function (done) {
+		initJSDOM({})
+			.then(() => import("../../../source/dom/updater.mjs"))
+			.then((updaterModule) => {
+				Updater = updaterModule["Updater"];
+				return import("../../../source/dom/customelement.mjs");
+			})
+			.then((m) => {
+				try {
+					CustomElement = m["CustomElement"];
+					registerCustomElement = m["registerCustomElement"];
+					document = getDocument();
+					done();
+				} catch (e) {
+					done(e);
+				}
+			})
+			.catch(done);
+	});
+
+	beforeEach(function () {
+		document.getElementById("mocks").innerHTML = html;
+	});
+
+	afterEach(function () {
+		document.getElementById("mocks").innerHTML = "";
+	});
+
+	function settle(ms = 30) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+
+	describe("light DOM", function () {
+		// net: this path already worked, because :scope resolves outside a shadow
+		// root, and it must keep working
+		it("should remove annotated nodes and keep the rest", async function () {
+			const container = document.getElementById("test1");
+			container.innerHTML = `
+                <div id="keep-me"></div>
+                <div id="drop-me" data-monster-remove></div>
+                <span data-monster-replace="path:label"></span>
+            `;
+
+			const updater = new Updater(container, { label: "rendered" });
+			await updater.run();
+			await settle();
+
+			expect(container.querySelector("#drop-me")).to.equal(null);
+			expect(container.querySelector("#keep-me")).to.not.equal(null);
+			expect(container.querySelector("span").textContent).to.equal("rendered");
+		});
+
+		it("should remove every annotated node, nested ones included", async function () {
+			const container = document.getElementById("test1");
+			container.innerHTML = `
+                <div id="outer" data-monster-remove>
+                    <div id="inner" data-monster-remove></div>
+                </div>
+                <div id="sibling"><div id="deep" data-monster-remove></div></div>
+                <span data-monster-replace="path:label"></span>
+            `;
+
+			const updater = new Updater(container, { label: "rendered" });
+			await updater.run();
+			await settle();
+
+			expect(container.querySelector("#outer")).to.equal(null);
+			expect(container.querySelector("#inner")).to.equal(null);
+			expect(container.querySelector("#deep")).to.equal(null);
+			expect(container.querySelector("#sibling")).to.not.equal(null);
+		});
+	});
+
+	describe("shadow DOM", function () {
+		const TAG = "monster-updater-remove-579";
+
+		before(function () {
+			if (!customElements.get(TAG)) {
+				class RemoveComponent extends CustomElement {
+					static getTag() {
+						return TAG;
+					}
+
+					get defaults() {
+						return Object.assign({}, super.defaults, {
+							label: "rendered",
+							templates: {
+								main: `
+                                    <div id="host">
+                                        <div id="keep-me"></div>
+                                        <div id="drop-me" data-monster-remove></div>
+                                        <span id="label" data-monster-replace="path:label"></span>
+                                    </div>
+                                `,
+							},
+						});
+					}
+				}
+
+				registerCustomElement(RemoveComponent);
+			}
+		});
+
+		// regression: the annotated node survived inside a shadow root
+		it("should remove annotated nodes from a component shadow root", async function () {
+			const element = document.createElement(TAG);
+			document.getElementById("test1").appendChild(element);
+			await settle();
+
+			expect(element.shadowRoot.querySelector("#drop-me")).to.equal(null);
+			expect(element.shadowRoot.querySelector("#keep-me")).to.not.equal(null);
+			expect(element.shadowRoot.querySelector("#label").textContent).to.equal(
+				"rendered",
+			);
+			expect(element.hasAttribute("data-monster-error")).to.be.false;
+		});
+
+		it("should keep the shadow root free of annotated nodes after an update", async function () {
+			const element = document.createElement(TAG);
+			document.getElementById("test1").appendChild(element);
+			await settle();
+
+			element.setOption("label", "changed");
+			await settle();
+
+			expect(element.shadowRoot.querySelector("#label").textContent).to.equal(
+				"changed",
+			);
+			expect(
+				element.shadowRoot.querySelectorAll("[data-monster-remove]").length,
+			).to.equal(0);
+		});
+
+		it("should remove an annotated node nested below the updater element", async function () {
+			const nestedTag = "monster-updater-remove-nested-579";
+
+			if (!customElements.get(nestedTag)) {
+				class NestedRemoveComponent extends CustomElement {
+					static getTag() {
+						return nestedTag;
+					}
+
+					get defaults() {
+						return Object.assign({}, super.defaults, {
+							label: "rendered",
+							templates: {
+								main: `
+                                    <div id="level-one">
+                                        <div id="level-two">
+                                            <em id="deep-drop" data-monster-remove></em>
+                                            <b id="deep-keep"></b>
+                                        </div>
+                                    </div>
+                                `,
+							},
+						});
+					}
+				}
+
+				registerCustomElement(NestedRemoveComponent);
+			}
+
+			const element = document.createElement(nestedTag);
+			document.getElementById("test1").appendChild(element);
+			await settle();
+
+			expect(element.shadowRoot.querySelector("#deep-drop")).to.equal(null);
+			expect(element.shadowRoot.querySelector("#deep-keep")).to.not.equal(null);
+		});
+	});
+});

package/test/cases/dom/updater.mjs

@@ -1665,6 +1665,78 @@ describe("DOM", function () {
           .catch((e) => done(new Error(e)));
       });
 
+      it("should not move unchanged keyed nodes issue #564", async function () {
+        const element = document.getElementById("test-patch");
+        const a = document.createElement("span");
+        const b = document.createElement("span");
+        a.dataset.key = "a";
+        b.dataset.key = "b";
+
+        const updater = new Updater(element, {
+          text: "",
+          contentNode: document.createElement("div"),
+          fragmentNode: document.createDocumentFragment(),
+          itemsArray: [],
+          keyedItems: [a, b],
+          keyedDataItems: [],
+          items: [],
+        });
+        updater.setCallback("getPatchKey", (value) => value?.dataset?.key);
+        await updater.run();
+
+        const target = document.getElementById("patch-keyed");
+        let moves = 0;
+        const appendChild = target.appendChild;
+        const insertBefore = target.insertBefore;
+        target.appendChild = function (...args) {
+          moves++;
+          return appendChild.apply(this, args);
+        };
+        target.insertBefore = function (...args) {
+          moves++;
+          return insertBefore.apply(this, args);
+        };
+
+        updater.getSubject().keyedItems = [a, b];
+        await new Promise((resolve) => setTimeout(resolve, 30));
+
+        expect(moves).to.equal(0);
+        expect(Array.from(target.children)).to.deep.equal([a, b]);
+      });
+
+      it("should dispose a keyed node replaced under the same key issue #564", async function () {
+        const element = document.getElementById("test-patch");
+        const first = document.createElement("span");
+        const replacement = document.createElement("span");
+        first.dataset.key = "same";
+        replacement.dataset.key = "same";
+        let disposeCount = 0;
+        addToObjectLink(
+          first,
+          customElementUpdaterLinkSymbol,
+          new Set([{dispose() { disposeCount++; }}]),
+        );
+
+        const updater = new Updater(element, {
+          text: "",
+          contentNode: document.createElement("div"),
+          fragmentNode: document.createDocumentFragment(),
+          itemsArray: [],
+          keyedItems: [first],
+          keyedDataItems: [],
+          items: [],
+        });
+        updater.setCallback("getPatchKey", (value) => value?.dataset?.key);
+        await updater.run();
+
+        updater.getSubject().keyedItems = [replacement];
+        await new Promise((resolve) => setTimeout(resolve, 30));
+
+        expect(disposeCount).to.equal(1);
+        expect(first.isConnected).to.equal(false);
+        expect(document.getElementById("patch-keyed").firstChild).to.equal(replacement);
+      });
+
       it("should remove stale keyed nodes and keep surviving node identity", function (done) {
         let element = document.getElementById("test-patch");
         const a = document.createElement("span");
@@ -2620,6 +2692,52 @@ describe("DOM", function () {
     });
   });
 
+  describe("Updater binding correctness issue #563", function () {
+    it("should ignore unchecked radios during retrieve", function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <input type="radio" value="selected" checked data-monster-bind="path:choice">
+        <input type="radio" value="unchecked" data-monster-bind="path:choice">
+      `;
+
+      const updater = new Updater(mocks, {choice: "initial"});
+      updater.retrieve();
+
+      expect(updater.getSubject().choice).to.equal("selected");
+    });
+
+    it("should not change select state for non-value attributes", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <select id="binding-select" data-monster-attributes="title path:title">
+          <option value="a">a</option>
+          <option value="b" selected>b</option>
+        </select>
+      `;
+
+      const updater = new Updater(mocks, {title: "label"});
+      await updater.run();
+
+      const select = document.getElementById("binding-select");
+      expect(select.title).to.equal("label");
+      expect(select.value).to.equal("b");
+    });
+
+    it("should evaluate static attribute and property commands", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="static-attribute" data-monster-attributes="title static:hello"></div>
+        <input id="static-property" data-monster-properties="value static:world">
+      `;
+
+      const updater = new Updater(mocks, {trigger: true});
+      await updater.run();
+
+      expect(document.getElementById("static-attribute").title).to.equal("hello");
+      expect(document.getElementById("static-property").value).to.equal("world");
+    });
+  });
+
   describe("Updater pipe failure recovery issue #498", function () {
     const waitForUpdate = () => new Promise((resolve) => setTimeout(resolve, 20));
 

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);
+        });
+
+    })
+
 })