@schukai/monster 4.153.0 → 4.154.0

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

@@ -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,161 @@ 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');
+        });
+    });
+
+    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),
+                );
+            }
+        });
+    });
+
+
+});

package/test/cases/util/clone.mjs

@@ -210,4 +210,119 @@ describe('Clone', function () {
 
     });
 
+    describe('cyclic graphs and constructor free copies issue #573', function () {
+
+        class NeedsArgument {
+            constructor(required) {
+                if (required === undefined) {
+                    throw new Error("required argument missing");
+                }
+                this.required = required;
+            }
+
+            describe() {
+                return `value:${this.required}`;
+            }
+        }
+
+        // net: behaviour that is already correct and must stay correct
+        it('should keep cloning plain nested structures deeply', function () {
+            let source = {a: {b: {c: 1}}, list: [1, {d: 2}]};
+            let result = clone(source);
+
+            expect(result).to.deep.equal(source);
+            expect(result.a).not.to.equal(source.a);
+            expect(result.list[1]).not.to.equal(source.list[1]);
+        });
+
+        it('should keep the prototype and instanceof of a cloned class instance', function () {
+            let source = new A({x: 1});
+            let result = clone(source);
+
+            expect(result).to.be.instanceOf(A);
+            expect(Object.getPrototypeOf(result)).to.equal(Object.getPrototypeOf(source));
+            expect(typeof result.a).to.equal('function');
+            expect(result.b).to.deep.equal({x: 1});
+        });
+
+        it('should keep honoring getClone()', function () {
+            let result = clone(new B({x: 1}));
+            expect(result).to.equal('DONE');
+        });
+
+        // regression: a cyclic graph must terminate instead of exhausting the stack
+        it('should clone a self referencing object', function () {
+            let source = {name: 'root'};
+            source.self = source;
+
+            let result = clone(source);
+
+            expect(result).not.to.equal(source);
+            expect(result.name).to.equal('root');
+            expect(result.self).to.equal(result);
+        });
+
+        it('should clone a cycle that runs through an array', function () {
+            let source = {items: []};
+            source.items.push(source);
+
+            let result = clone(source);
+
+            expect(result.items[0]).to.equal(result);
+            expect(result.items).not.to.equal(source.items);
+        });
+
+        it('should clone a mutual reference between two objects', function () {
+            let first = {name: 'first'};
+            let second = {name: 'second', first};
+            first.second = second;
+
+            let result = clone(first);
+
+            expect(result.second.first).to.equal(result);
+            expect(result.second).not.to.equal(second);
+        });
+
+        it('should preserve a shared reference instead of duplicating it', function () {
+            let shared = {value: 1};
+            let source = {left: shared, right: shared};
+
+            let result = clone(source);
+
+            expect(result.left).to.equal(result.right);
+            expect(result.left).not.to.equal(shared);
+        });
+
+        it('should keep honoring getClone() for an object reached inside a cycle', function () {
+            let source = {inner: new B({x: 1})};
+            source.self = source;
+
+            let result = clone(source);
+
+            expect(result.inner).to.equal('DONE');
+            expect(result.self).to.equal(result);
+        });
+
+        // regression: copying must not run the constructor of the source class
+        it('should clone an instance whose constructor requires an argument', function () {
+            let source = new NeedsArgument('payload');
+
+            let result = clone(source);
+
+            expect(result).to.be.instanceOf(NeedsArgument);
+            expect(result).not.to.equal(source);
+            expect(result.required).to.equal('payload');
+            expect(result.describe()).to.equal('value:payload');
+        });
+
+        it('should clone a nested instance whose constructor requires an argument', function () {
+            let source = {level: {instance: new NeedsArgument(7)}};
+
+            let result = clone(source);
+
+            expect(result.level.instance).to.be.instanceOf(NeedsArgument);
+            expect(result.level.instance.required).to.equal(7);
+        });
+    });
+
 });