@schukai/monster 4.148.0 → 4.148.2

package/test/cases/dom/updater.mjs

@@ -383,6 +383,21 @@ describe("DOM", function () {
         expect(u.getSubject().a).to.be.equal(1);
       });
 
+      it("run() should accept dictionary payload keys issue #494", async function () {
+        element.innerHTML = `<span data-monster-replace="path:nested.value"></span>`;
+        const u = new Updater(element, {
+          hasOwnProperty: "payload",
+          nested: { value: "rendered" },
+        });
+
+        try {
+          await u.run();
+          expect(element.textContent).to.equal("rendered");
+        } finally {
+          u.dispose();
+        }
+      });
+
       it("enableEventProcessing() should be chainable", function () {
         const u = new Updater(element);
         expect(u.enableEventProcessing()).to.be.instanceof(Updater);
@@ -1892,6 +1907,37 @@ describe("DOM", function () {
   });
 
   describe("Updater reactive updates", function () {
+    [false, true].forEach((batchUpdates) => {
+      it(`should preserve microtask changes with batchUpdates=${batchUpdates} issue #496`, async function () {
+        let mocks = document.getElementById("mocks");
+        mocks.innerHTML = `
+          <span id="microtask-a" data-monster-replace="path:a"></span>
+          <span id="microtask-b" data-monster-replace="path:b"></span>
+        `;
+
+        const updater = new Updater(mocks, { a: "A1", b: "B1" });
+        updater.setBatchUpdates(batchUpdates);
+
+        try {
+          await updater.run();
+          const subject = updater.getSubject();
+          subject.a = "A2";
+          queueMicrotask(() => {
+            subject.b = "B2";
+          });
+
+          await new Promise((resolve) => setTimeout(resolve, 20));
+
+          expect(subject.a).to.equal("A2");
+          expect(subject.b).to.equal("B2");
+          expect(document.getElementById("microtask-a").textContent).to.equal("A2");
+          expect(document.getElementById("microtask-b").textContent).to.equal("B2");
+        } finally {
+          updater.dispose();
+        }
+      });
+    });
+
     it("should update the DOM when the subject changes", function (done) {
       let mocks = document.getElementById("mocks");
       mocks.innerHTML = html1;
@@ -2017,4 +2063,251 @@ describe("DOM", function () {
         .catch((e) => done(e));
     });
   });
+
+  describe("Updater event lifecycle issue #497", function () {
+    const waitForBinding = () => new Promise((resolve) => setTimeout(resolve, 80));
+
+    it("should debounce different bound controls independently", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="event-root">
+          <input id="event-first" data-monster-bind="path:first">
+          <input id="event-second" data-monster-bind="path:second">
+        </div>
+      `;
+      const updater = new Updater(document.getElementById("event-root"), {});
+      updater.enableEventProcessing();
+
+      try {
+        const first = document.getElementById("event-first");
+        const second = document.getElementById("event-second");
+        first.value = "A";
+        first.dispatchEvent(new Event("input", { bubbles: true, composed: true }));
+        second.value = "B";
+        second.dispatchEvent(new Event("input", { bubbles: true, composed: true }));
+
+        await waitForBinding();
+
+        expect(updater.getSubject().first).to.equal("A");
+        expect(updater.getSubject().second).to.equal("B");
+      } finally {
+        updater.dispose();
+      }
+    });
+
+    it("should coalesce a soft keyboard event burst to the latest value", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="keyboard-root">
+          <input id="keyboard-input" data-monster-bind="path:value">
+        </div>
+      `;
+      const updater = new Updater(document.getElementById("keyboard-root"), {});
+      updater.enableEventProcessing();
+
+      try {
+        const input = document.getElementById("keyboard-input");
+        input.value = "intermediate";
+        input.dispatchEvent(new InputEvent("input", {
+          bubbles: true,
+          composed: true,
+          data: "i",
+          isComposing: true,
+        }));
+        input.value = "final";
+        input.dispatchEvent(new KeyboardEvent("keyup", { bubbles: true, composed: true }));
+        input.dispatchEvent(new Event("change", { bubbles: true, composed: true }));
+
+        await waitForBinding();
+
+        expect(updater.getSubject().value).to.equal("final");
+      } finally {
+        updater.dispose();
+      }
+    });
+
+    it("disableEventProcessing() should cancel pending binding work", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="disable-root">
+          <input id="disable-input" data-monster-bind="path:value">
+        </div>
+      `;
+      const updater = new Updater(document.getElementById("disable-root"), {});
+      updater.enableEventProcessing();
+
+      try {
+        const input = document.getElementById("disable-input");
+        input.value = "ignored";
+        input.dispatchEvent(new Event("input", { bubbles: true, composed: true }));
+        updater.disableEventProcessing();
+
+        await waitForBinding();
+
+        expect(updater.getSubject()).to.not.have.property("value");
+      } finally {
+        updater.dispose();
+      }
+    });
+
+    it("dispose() should cancel pending binding work", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="dispose-root">
+          <input id="dispose-input" data-monster-bind="path:value">
+        </div>
+      `;
+      const updater = new Updater(document.getElementById("dispose-root"), {});
+      const subject = updater.getSubject();
+      updater.enableEventProcessing();
+
+      const input = document.getElementById("dispose-input");
+      input.value = "ignored";
+      input.dispatchEvent(new Event("input", { bubbles: true, composed: true }));
+      updater.dispose();
+
+      await waitForBinding();
+
+      expect(subject).to.not.have.property("value");
+    });
+
+    it("should remove previously registered event types before re-enabling", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="types-root">
+          <input id="types-input" data-monster-bind="path:value">
+        </div>
+      `;
+      const updater = new Updater(document.getElementById("types-root"), {});
+      updater.enableEventProcessing();
+      updater.setEventTypes(["blur"]);
+      updater.enableEventProcessing();
+
+      try {
+        const input = document.getElementById("types-input");
+        input.value = "stale-input-listener";
+        input.dispatchEvent(new Event("input", { bubbles: true, composed: true }));
+        await waitForBinding();
+        expect(updater.getSubject()).to.not.have.property("value");
+
+        input.value = "blur-value";
+        input.dispatchEvent(new Event("blur", { bubbles: false, composed: true }));
+        await waitForBinding();
+        expect(updater.getSubject().value).to.equal("blur-value");
+      } finally {
+        updater.dispose();
+      }
+    });
+  });
+
+  describe("Updater pipe failure recovery issue #498", function () {
+    const waitForUpdate = () => new Promise((resolve) => setTimeout(resolve, 20));
+
+    it("should preserve and recover replace content", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `<span id="failure-replace" data-monster-replace="path:value | call:unstable"></span>`;
+      const updater = new Updater(mocks, { value: "first" });
+      let failing = false;
+      updater.setCallback("unstable", (value) => {
+        if (failing) throw new Error("probe failure");
+        return value;
+      });
+
+      try {
+        await updater.run();
+        const target = document.getElementById("failure-replace");
+        expect(target.textContent).to.equal("first");
+
+        failing = true;
+        updater.getSubject().value = "second";
+        await waitForUpdate();
+        expect(target.textContent).to.equal("first");
+        expect(target.getAttribute("data-monster-error")).to.equal("probe failure");
+
+        failing = false;
+        updater.getSubject().value = "third";
+        await waitForUpdate();
+        expect(target.textContent).to.equal("third");
+        expect(target.hasAttribute("data-monster-error")).to.be.false;
+      } finally {
+        updater.dispose();
+      }
+    });
+
+    it("should preserve attributes while valid sibling bindings continue", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <span
+          id="failure-attribute"
+          data-monster-attributes="title path:value | call:unstable, data-valid path:sibling"
+        ></span>
+      `;
+      const updater = new Updater(mocks, { value: "first", sibling: "one" });
+      let failing = false;
+      updater.setCallback("unstable", (value) => {
+        if (failing) throw new Error("probe failure");
+        return value;
+      });
+
+      try {
+        await updater.run();
+        const target = document.getElementById("failure-attribute");
+        expect(target.getAttribute("title")).to.equal("first");
+
+        failing = true;
+        updater.getSubject().value = "second";
+        updater.getSubject().sibling = "two";
+        await waitForUpdate();
+        expect(target.getAttribute("title")).to.equal("first");
+        expect(target.getAttribute("data-valid")).to.equal("two");
+        expect(target.getAttribute("data-monster-error")).to.equal("probe failure");
+
+        failing = false;
+        updater.getSubject().value = "third";
+        await waitForUpdate();
+        expect(target.getAttribute("title")).to.equal("third");
+        expect(target.hasAttribute("data-monster-error")).to.be.false;
+      } finally {
+        updater.dispose();
+      }
+    });
+
+    it("should preserve properties while valid sibling bindings continue", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <input
+          id="failure-property"
+          data-monster-properties="value path:value | call:unstable, disabled path:disabled"
+        >
+      `;
+      const updater = new Updater(mocks, { value: "first", disabled: false });
+      let failing = false;
+      updater.setCallback("unstable", (value) => {
+        if (failing) throw new Error("probe failure");
+        return value;
+      });
+
+      try {
+        await updater.run();
+        const target = document.getElementById("failure-property");
+        expect(target.value).to.equal("first");
+
+        failing = true;
+        updater.getSubject().value = "second";
+        updater.getSubject().disabled = true;
+        await waitForUpdate();
+        expect(target.value).to.equal("first");
+        expect(target.disabled).to.be.true;
+        expect(target.getAttribute("data-monster-error")).to.equal("probe failure");
+
+        failing = false;
+        updater.getSubject().value = "third";
+        await waitForUpdate();
+        expect(target.value).to.equal("third");
+        expect(target.hasAttribute("data-monster-error")).to.be.false;
+      } finally {
+        updater.dispose();
+      }
+    });
+  });
 });

package/test/cases/types/proxyobserver.mjs

@@ -292,4 +292,56 @@ describe('ProxyObserver', function () {
         });
     });
 
+    describe('native object compatibility issue #495', function () {
+        it('should preserve Date, Map, and Set identity and native methods', function () {
+            const date = new Date('2026-01-01T00:00:00Z');
+            const map = new Map([['key', 'value']]);
+            const set = new Set(['value']);
+            const proxy = new ProxyObserver({date, map, set});
+            const subject = proxy.getSubject();
+
+            expect(subject.date).to.equal(date);
+            expect(subject.date.getTime()).to.equal(date.getTime());
+            expect(subject.map).to.equal(map);
+            expect(subject.map.get('key')).to.equal('value');
+            expect(subject.set).to.equal(set);
+            expect(subject.set.has('value')).to.be.true;
+        });
+
+        it('should not notify for internal Map and Set mutations', async function () {
+            const proxy = new ProxyObserver({map: new Map(), set: new Set()});
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            proxy.getSubject().map.set('key', 'value');
+            proxy.getSubject().set.add('value');
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(notifications).to.equal(0);
+        });
+
+        it('should notify when a complete native object property is replaced', async function () {
+            const proxy = new ProxyObserver({map: new Map()});
+            const replacement = new Map([['key', 'value']]);
+            let notifications = 0;
+            let resolveNotification;
+            const notified = new Promise((resolve) => {
+                resolveNotification = resolve;
+            });
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+                resolveNotification();
+            }));
+
+            proxy.getSubject().map = replacement;
+            await notified;
+
+            expect(proxy.getRealSubject().map).to.equal(replacement);
+            expect(proxy.getSubject().map).to.equal(replacement);
+            expect(notifications).to.equal(1);
+        });
+    });
+
 })

package/test/cases/util/clone.mjs

@@ -107,6 +107,30 @@ describe('Clone', function () {
             let b = clone(a);
             expect(a.x).is.equal(b.x)
         });
+
+        it('should clone objects with an own hasOwnProperty key issue #494', function () {
+            const source = {
+                hasOwnProperty: 'payload',
+                nested: {value: 1},
+            };
+
+            const result = clone(source);
+
+            expect(result).to.deep.equal(source);
+            expect(result).not.to.equal(source);
+            expect(result.nested).not.to.equal(source.nested);
+        });
+
+        it('should deeply clone null-prototype dictionaries issue #494', function () {
+            const source = Object.create(null);
+            source.nested = {value: 1};
+
+            const result = clone(source);
+
+            expect(Object.getPrototypeOf(result)).to.equal(null);
+            expect(result.nested).to.deep.equal({value: 1});
+            expect(result.nested).not.to.equal(source.nested);
+        });
     })
     describe('.clone(function)', function () {