@schukai/monster 4.152.0 → 4.153.1

package/test/cases/dom/slotted-nodes.mjs

@@ -1,14 +1,61 @@
 import {expect} from 'chai';
 import {getSlottedNodes} from "../../../source/dom/slotted.mjs";
+import {getSlottedElements} from "../../../source/dom/slotted.mjs";
+import {initJSDOM} from "../../util/jsdom.mjs";
 
 
 describe('getSlottedNodes', () => {
 
+    before(async () => {
+        await initJSDOM();
+    });
+
 
     it('should return an empty Set if there is no ShadowRoot', () => {
         expect(getSlottedNodes).is.a('function');
     });
 
+    it('should ignore text nodes when applying an element query issue #567', () => {
+        const host = document.createElement('div');
+        host.append(' whitespace ');
+        const child = document.createElement('span');
+        child.className = 'match';
+        host.appendChild(child);
+        host.attachShadow({mode: 'open'}).innerHTML = '<slot></slot>';
+        document.body.appendChild(host);
+
+        expect([...getSlottedNodes.call(host, '.match')]).to.deep.equal([child]);
+        host.remove();
+    });
+
+    it('should match empty and spaced slot names without selector interpolation issue #567', () => {
+        const host = document.createElement('div');
+        const defaultChild = document.createElement('span');
+        const namedChild = document.createElement('span');
+        namedChild.slot = 'some slot';
+        host.append(defaultChild, namedChild);
+        host.attachShadow({mode: 'open'}).innerHTML =
+            '<slot name=""></slot><slot name="some slot"></slot>';
+        document.body.appendChild(host);
+
+        expect([...getSlottedElements.call(host, undefined, null)]).to.deep.equal([defaultChild]);
+        expect([...getSlottedElements.call(host, undefined, 'some slot')]).to.deep.equal([namedChild]);
+        host.remove();
+    });
+
+    it('should accept the internally managed closed shadow root issue #567', () => {
+        const host = document.createElement('div');
+        const child = document.createElement('span');
+        host.appendChild(child);
+        const root = host.attachShadow({mode: 'closed'});
+        root.innerHTML = '<slot></slot>';
+        document.body.appendChild(host);
+
+        expect(host.shadowRoot).to.equal(null);
+        expect([...getSlottedElements.call(host, undefined, undefined, root)])
+            .to.deep.equal([child]);
+        host.remove();
+    });
 
-});
 
+});

package/test/cases/dom/template.mjs

@@ -81,6 +81,17 @@ describe('Template', function () {
                 expect(t).is.instanceof(Template);
 
             })
+
+            it('should resolve from a text node context issue #567', function () {
+                const container = document.createElement('div');
+                const text = document.createTextNode('context');
+                container.appendChild(text);
+                document.body.appendChild(container);
+
+                const template = findDocumentTemplate('mytemplate', text);
+                expect(template).to.be.instanceof(Template);
+                container.remove();
+            });
         });
 
         describe('Thmened Template', function () {

package/test/cases/dom/updater.mjs

@@ -780,7 +780,7 @@ describe("DOM", function () {
 
       [false, true].forEach((batchUpdates) => {
         it(`should bulk insert and reuse indexed entries with batchUpdates=${batchUpdates} issue #548`, async function () {
-          this.timeout(5000);
+          this.timeout(20000);
           const mocks = document.getElementById("mocks");
           mocks.innerHTML = `
             <template id="bulk-row">
@@ -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/types/proxyobserver.mjs

@@ -241,6 +241,40 @@ describe('ProxyObserver', function () {
             proxy.attachObserver(observer);
             delete proxy.getSubject().a;
         });
+
+        it('should ignore missing and inherited deletes without notifying issue #570', async function () {
+            const prototype = {inherited: true};
+            const value = Object.create(prototype);
+            const proxy = new ProxyObserver(value);
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            expect(() => delete proxy.getSubject().missing).to.not.throw();
+            expect(() => delete proxy.getSubject().inherited).to.not.throw();
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(proxy.getSubject().inherited).to.equal(true);
+            expect(notifications).to.equal(0);
+        });
+
+        it('should report failed non-configurable deletes without notifying issue #570', async function () {
+            const value = {};
+            Object.defineProperty(value, 'fixed', {
+                configurable: false,
+                value: true,
+            });
+            const proxy = new ProxyObserver(value);
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            expect(Reflect.deleteProperty(proxy.getSubject(), 'fixed')).to.equal(false);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(notifications).to.equal(0);
+        });
     });
 
     describe('symbol properties', function () {
@@ -342,6 +376,47 @@ describe('ProxyObserver', function () {
             expect(proxy.getSubject().map).to.equal(replacement);
             expect(notifications).to.equal(1);
         });
+
+        it('should obey frozen-property proxy invariants issue #570', function () {
+            const nested = {value: true};
+            const frozen = Object.freeze({nested});
+            const subject = new ProxyObserver({frozen}).getSubject();
+
+            expect(() => subject.frozen.nested).to.not.throw();
+            expect(subject.frozen.nested).to.equal(nested);
+        });
+
+        it('should preserve confirmed internal-slot native objects issue #570', async function () {
+            const weakKey = {};
+            const regexp = /monster/g;
+            const buffer = new ArrayBuffer(8);
+            const view = new DataView(buffer);
+            const typed = new Uint8Array(buffer);
+            const weakMap = new WeakMap([[weakKey, 'value']]);
+            const weakSet = new WeakSet([weakKey]);
+            const promise = Promise.resolve('resolved');
+            const subject = new ProxyObserver({
+                regexp,
+                buffer,
+                view,
+                typed,
+                weakMap,
+                weakSet,
+                promise,
+            }).getSubject();
+
+            expect(subject.regexp).to.equal(regexp);
+            expect(subject.regexp.test('monster')).to.equal(true);
+            expect(subject.buffer).to.equal(buffer);
+            expect(subject.buffer.byteLength).to.equal(8);
+            expect(subject.view).to.equal(view);
+            expect(subject.view.byteLength).to.equal(8);
+            expect(subject.typed).to.equal(typed);
+            expect(subject.typed.length).to.equal(8);
+            expect(subject.weakMap.get(weakKey)).to.equal('value');
+            expect(subject.weakSet.has(weakKey)).to.equal(true);
+            expect(await subject.promise).to.equal('resolved');
+        });
     });
 
 })

package/test/cases/util/processing.mjs

@@ -12,7 +12,7 @@ describe('Processing', function () {
             let t = +new Date();
 
             const desiredDelay = 200;
-            this.timeout(desiredDelay+100);
+            this.timeout(2000);
             
             // delay 12 
             new Processing((v) => {
@@ -33,7 +33,7 @@ describe('Processing', function () {
                     expect(counter).to.be.equal(4);
                     expect(v === 'test').to.be.true;
                     // check delay
-                    expect(+new Date() > t + desiredDelay+1).to.be.true;
+                    expect(+new Date() >= t + desiredDelay).to.be.true;
                 } catch (e) {
                     return done(e);
                 }
@@ -107,4 +107,4 @@ describe('Processing', function () {
 
     });
 
-});
+});