@ng-org/alien-deepsignals 0.1.2-alpha.2 → 0.1.2-alpha.4

package/dist/test/lib/index.test.js

@@ -0,0 +1,807 @@
+"use strict";
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+const vitest_1 = require("vitest");
+const __1 = require("../..");
+(0, vitest_1.describe)("deepsignal/core", () => {
+    let nested = { b: 2 };
+    let array = [3, nested];
+    let state = { a: 1, nested, array };
+    let store = (0, index_1.deepSignal)(state);
+    const window = globalThis;
+    (0, vitest_1.beforeEach)(() => {
+        nested = { b: 2 };
+        array = [3, nested];
+        state = { a: 1, nested, array };
+        store = (0, index_1.deepSignal)(state);
+    });
+    (0, vitest_1.describe)("get - plain", () => {
+        (0, vitest_1.it)("should return plain objects/arrays", () => {
+            (0, vitest_1.expect)(store.nested).to.deep.equal({ b: 2 });
+            (0, vitest_1.expect)(store.array).to.deep.equal([3, { b: 2 }]);
+            (0, vitest_1.expect)(store.array[1]).to.deep.equal({ b: 2 });
+        });
+        (0, vitest_1.it)("should return plain primitives", () => {
+            (0, vitest_1.expect)(store.a).to.equal(1);
+            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+            (0, vitest_1.expect)(store.array[0]).to.equal(3);
+            (0, vitest_1.expect)(typeof store.array[1] === "object" && store.array[1].b).to.equal(2);
+            (0, vitest_1.expect)(store.array.length).to.equal(2);
+        });
+        (0, vitest_1.it)("should support reading from getters", () => {
+            const store = (0, index_1.deepSignal)({
+                counter: 1,
+                get double() {
+                    return store.counter * 2;
+                },
+            });
+            (0, vitest_1.expect)(store.double).to.equal(2);
+            store.counter = 2;
+            (0, vitest_1.expect)(store.double).to.equal(4);
+        });
+        (0, vitest_1.it)("should support getters returning other parts of the state", () => {
+            const store = (0, index_1.deepSignal)({
+                switch: "a",
+                a: { data: "a" },
+                b: { data: "b" },
+                get aOrB() {
+                    return store.switch === "a" ? store.a : store.b;
+                },
+            });
+            (0, vitest_1.expect)(store.aOrB.data).to.equal("a");
+            store.switch = "b";
+            (0, vitest_1.expect)(store.aOrB.data).to.equal("b");
+        });
+        (0, vitest_1.it)("should support getters using ownKeys traps", () => {
+            const state = (0, index_1.deepSignal)({
+                x: {
+                    a: 1,
+                    b: 2,
+                },
+                get y() {
+                    return Object.values(state.x);
+                },
+            });
+            (0, vitest_1.expect)(state.y).to.deep.equal([1, 2]);
+        });
+        (0, vitest_1.it)("should work with normal functions", () => {
+            const store = (0, index_1.deepSignal)({
+                value: 1,
+                isBigger: (newValue) => store.value < newValue,
+                sum(newValue) {
+                    return store.value + newValue;
+                },
+                replace: (newValue) => {
+                    store.value = newValue;
+                },
+            });
+            (0, vitest_1.expect)(store.isBigger(2)).to.equal(true);
+            (0, vitest_1.expect)(store.sum(2)).to.equal(3);
+            (0, vitest_1.expect)(store.value).to.equal(1);
+            store.replace(2);
+            (0, vitest_1.expect)(store.value).to.equal(2);
+        });
+    });
+    (0, vitest_1.describe)("set", () => {
+        (0, vitest_1.it)("should update like plain objects/arrays", () => {
+            (0, vitest_1.expect)(store.a).to.equal(1);
+            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+            store.a = 2;
+            store.nested.b = 3;
+            (0, vitest_1.expect)(store.a).to.equal(2);
+            (0, vitest_1.expect)(store.nested.b).to.equal(3);
+        });
+        // TODO: Remove the .value access semantics.
+        (0, vitest_1.it)("should support setting values with setters", () => {
+            const store = (0, index_1.deepSignal)({
+                counter: 1,
+                get double() {
+                    return store.counter * 2;
+                },
+                set double(val) {
+                    store.counter = val / 2;
+                },
+            });
+            (0, vitest_1.expect)(store.counter).to.equal(1);
+            store.double = 4;
+            (0, vitest_1.expect)(store.counter).to.equal(2);
+        });
+        (0, vitest_1.it)("should update array length", () => {
+            let state = { a: 1, nested, array };
+            let store = (0, index_1.deepSignal)(state);
+            (0, vitest_1.expect)(store.array.length).to.equal(2);
+            store.array.push(4);
+            (0, vitest_1.expect)(store.array.length).to.equal(3);
+            store.array.splice(1, 2);
+            (0, vitest_1.expect)(store.array.length).to.equal(1);
+        });
+        (0, vitest_1.it)("should update when mutations happen", () => {
+            (0, vitest_1.expect)(store.a).to.equal(1);
+            store.a = 11;
+            (0, vitest_1.expect)(store.a).to.equal(11);
+        });
+        (0, vitest_1.it)("should support setting getters on the fly", () => {
+            const store = (0, index_1.deepSignal)({
+                counter: 1,
+            });
+            Object.defineProperty(store, "double", {
+                get: function () {
+                    return store.counter * 2;
+                },
+            });
+            (0, vitest_1.expect)(store.double).to.equal(2);
+            store.counter = 2;
+            (0, vitest_1.expect)(store.double).to.equal(4);
+        });
+        (0, vitest_1.it)("should copy object like plain JavaScript", () => {
+            const store = (0, index_1.deepSignal)({
+                b: { id: 1, nested: { id: 1 } },
+            });
+            store.a = store.b;
+            (0, vitest_1.expect)(store.a.id).to.equal(1);
+            (0, vitest_1.expect)(store.b.id).to.equal(1);
+            (0, vitest_1.expect)(store.a.nested.id).to.equal(1);
+            (0, vitest_1.expect)(store.b.nested.id).to.equal(1);
+            store.a.id = 2;
+            store.a.nested.id = 2;
+            (0, vitest_1.expect)(store.a.id).to.equal(2);
+            (0, vitest_1.expect)(store.b.id).to.equal(2);
+            (0, vitest_1.expect)(store.a.nested.id).to.equal(2);
+            (0, vitest_1.expect)(store.b.nested.id).to.equal(2);
+            store.b.id = 3;
+            store.b.nested.id = 3;
+            (0, vitest_1.expect)(store.b.id).to.equal(3);
+            (0, vitest_1.expect)(store.a.id).to.equal(3);
+            (0, vitest_1.expect)(store.a.nested.id).to.equal(3);
+            (0, vitest_1.expect)(store.b.nested.id).to.equal(3);
+            store.a.id = 4;
+            store.a.nested.id = 4;
+            (0, vitest_1.expect)(store.a.id).to.equal(4);
+            (0, vitest_1.expect)(store.b.id).to.equal(4);
+            (0, vitest_1.expect)(store.a.nested.id).to.equal(4);
+            (0, vitest_1.expect)(store.b.nested.id).to.equal(4);
+        });
+        (0, vitest_1.it)("should be able to reset values with Object.assign", () => {
+            const initialNested = { ...nested };
+            const initialState = { ...state, nested: initialNested };
+            store.a = 2;
+            store.nested.b = 3;
+            Object.assign(store, initialState);
+            (0, vitest_1.expect)(store.a).to.equal(1);
+            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+        });
+    });
+    (0, vitest_1.describe)("delete", () => {
+        (0, vitest_1.it)("should delete properties before they are accessed", () => {
+            delete store.a;
+            (0, vitest_1.expect)(store.a).to.equal(undefined);
+        });
+        (0, vitest_1.it)("should delete properties after they are accessed", () => {
+            (0, vitest_1.expect)(store.a).to.equal(1);
+            delete store.a;
+            (0, vitest_1.expect)(store.a).to.equal(undefined);
+        });
+        (0, vitest_1.it)("should delete nested properties before they are accessed", () => {
+            delete store.nested.b;
+            (0, vitest_1.expect)(store.nested.b).to.equal(undefined);
+        });
+        (0, vitest_1.it)("should delete nested properties after they are accessed", () => {
+            (0, vitest_1.expect)(store.nested.b).to.equal(2);
+            delete store.nested.b;
+            (0, vitest_1.expect)(store.nested.b).to.equal(undefined);
+        });
+        (0, vitest_1.it)("should delete properties in arrays before they are accessed", () => {
+            delete store.array[0];
+            (0, vitest_1.expect)(store.array[0]).to.equal(undefined);
+        });
+        (0, vitest_1.it)("should delete properties in arrays after they are accessed", () => {
+            (0, vitest_1.expect)(store.array[0]).to.equal(3);
+            delete store.array[0];
+            (0, vitest_1.expect)(store.array[0]).to.equal(undefined);
+        });
+    });
+    (0, vitest_1.describe)("ownKeys", () => {
+        (0, vitest_1.it)("should return own properties in objects", () => {
+            const state = { a: 1, b: 2 };
+            const store = (0, index_1.deepSignal)(state);
+            let sum = 0;
+            for (const property in store) {
+                sum += store[property];
+            }
+            (0, vitest_1.expect)(sum).to.equal(3);
+        });
+        (0, vitest_1.it)("should return own properties in arrays", () => {
+            const state = [1, 2];
+            const store = (0, index_1.deepSignal)(state);
+            let sum = 0;
+            for (const property of store) {
+                sum += property;
+            }
+            (0, vitest_1.expect)(sum).to.equal(3);
+        });
+        (0, vitest_1.it)("should spread objects correctly", () => {
+            const store2 = { ...store };
+            (0, vitest_1.expect)(store2.a).to.equal(1);
+            (0, vitest_1.expect)(store2.nested.b).to.equal(2);
+            (0, vitest_1.expect)(store2.array[0]).to.equal(3);
+            (0, vitest_1.expect)(typeof store2.array[1] === "object" && store2.array[1].b).to.equal(2);
+        });
+        (0, vitest_1.it)("should spread arrays correctly", () => {
+            const array2 = [...store.array];
+            (0, vitest_1.expect)(array2[0]).to.equal(3);
+            (0, vitest_1.expect)(typeof array2[1] === "object" && array2[1].b).to.equal(2);
+        });
+    });
+    (0, vitest_1.describe)("computations", () => {
+        (0, vitest_1.it)("should subscribe to values mutated with setters", () => {
+            const store = (0, index_1.deepSignal)({
+                counter: 1,
+                get double() {
+                    return store.counter * 2;
+                },
+                set double(val) {
+                    store.counter = val / 2;
+                },
+            });
+            let counter = 0;
+            let double = 0;
+            (0, __1.effect)(() => {
+                counter = store.counter;
+                double = store.double;
+            });
+            (0, vitest_1.expect)(counter).to.equal(1);
+            (0, vitest_1.expect)(double).to.equal(2);
+            store.double = 4;
+            (0, vitest_1.expect)(counter).to.equal(2);
+            (0, vitest_1.expect)(double).to.equal(4);
+        });
+        (0, vitest_1.it)("should subscribe to changes when an item is removed from the array", () => {
+            const store = (0, index_1.deepSignal)([0, 0, 0]);
+            let sum = 0;
+            (0, __1.effect)(() => {
+                sum = 0;
+                sum = store.reduce((sum) => sum + 1, 0);
+            });
+            (0, vitest_1.expect)(sum).to.equal(3);
+            store.splice(2, 1);
+            (0, vitest_1.expect)(sum).to.equal(2);
+        });
+        (0, vitest_1.it)("should subscribe to changes to for..in loops", () => {
+            const state = { a: 0, b: 0 };
+            const store = (0, index_1.deepSignal)(state);
+            let sum = 0;
+            (0, __1.effect)(() => {
+                sum = 0;
+                for (const _ in store) {
+                    sum += 1;
+                }
+            });
+            (0, vitest_1.expect)(sum).to.equal(2);
+            store.c = 0;
+            (0, vitest_1.expect)(sum).to.equal(3);
+            delete store.c;
+            (0, vitest_1.expect)(sum).to.equal(2);
+        });
+        (0, vitest_1.it)("should not retrigger effects when unrelated object branches change", () => {
+            const store = (0, index_1.deepSignal)({
+                alpha: { value: 1 },
+                beta: { value: 2 },
+            });
+            let runs = 0;
+            (0, __1.effect)(() => {
+                runs += 1;
+                store.alpha.value;
+            });
+            (0, vitest_1.expect)(runs).to.equal(1);
+            store.beta.value = 3;
+            (0, vitest_1.expect)(runs).to.equal(1);
+        });
+        (0, vitest_1.it)("should not retrigger effects for untouched Set entries", () => {
+            const store = (0, index_1.deepSignal)({
+                set: new Set([
+                    { id: "a", data: { value: 1 } },
+                    { id: "b", data: { value: 2 } },
+                ]),
+            }, {
+                syntheticIdPropertyName: "id",
+                propGenerator: ({ object }) => ({ syntheticId: object.id }),
+            });
+            const [entryA, entryB] = Array.from(store.set);
+            let runs = 0;
+            (0, __1.effect)(() => {
+                runs += 1;
+                entryA.data.value;
+            });
+            (0, vitest_1.expect)(runs).to.equal(1);
+            entryB.data.value = 5;
+            (0, vitest_1.expect)(runs).to.equal(1);
+        });
+        (0, vitest_1.it)("should subscribe to array iteration via Symbol.iterator", () => {
+            const store = (0, index_1.deepSignal)([1, 2]);
+            let total = 0;
+            (0, __1.effect)(() => {
+                total = 0;
+                for (const value of store) {
+                    total += value;
+                }
+            });
+            (0, vitest_1.expect)(total).to.equal(3);
+            store.push(3);
+            (0, vitest_1.expect)(total).to.equal(6);
+        });
+        (0, vitest_1.it)("should subscribe to Set iteration via Symbol.iterator", () => {
+            const store = (0, index_1.deepSignal)({ set: new Set([1, 2]) });
+            let total = 0;
+            (0, __1.effect)(() => {
+                total = 0;
+                for (const value of store.set) {
+                    total += value;
+                }
+            });
+            (0, vitest_1.expect)(total).to.equal(3);
+            store.set.add(3);
+            (0, vitest_1.expect)(total).to.equal(6);
+            store.set.delete(1);
+            (0, vitest_1.expect)(total).to.equal(5);
+        });
+        (0, vitest_1.it)("should subscribe when using Set iterator helper chains", () => {
+            const store = (0, index_1.deepSignal)({ set: new Set([1]) });
+            let reduced = 0;
+            (0, __1.effect)(() => {
+                reduced = store.set
+                    .map((value) => value)
+                    .reduce((acc, value) => acc + value, 0);
+            });
+            (0, vitest_1.expect)(reduced).to.equal(1);
+            store.set.add(2);
+            (0, vitest_1.expect)(reduced).to.equal(3);
+            store.set.delete(1);
+            (0, vitest_1.expect)(reduced).to.equal(2);
+        });
+        (0, vitest_1.it)("should subscribe to changes for Object.getOwnPropertyNames()", () => {
+            const state = { a: 1, b: 2 };
+            const store = (0, index_1.deepSignal)(state);
+            let sum = 0;
+            (0, __1.effect)(() => {
+                sum = 0;
+                const keys = Object.getOwnPropertyNames(store);
+                for (const _ of keys) {
+                    sum += 1;
+                }
+            });
+            (0, vitest_1.expect)(sum).to.equal(2);
+            store.c = 0;
+            (0, vitest_1.expect)(sum).to.equal(3);
+            delete store.a;
+            (0, vitest_1.expect)(sum).to.equal(2);
+        });
+        (0, vitest_1.it)("should subscribe to changes to Object.keys/values/entries()", () => {
+            const state = { a: 1, b: 2 };
+            const store = (0, index_1.deepSignal)(state);
+            let keys = 0;
+            let values = 0;
+            let entries = 0;
+            (0, __1.effect)(() => {
+                keys = 0;
+                Object.keys(store).forEach(() => (keys += 1));
+            });
+            (0, __1.effect)(() => {
+                values = 0;
+                Object.values(store).forEach(() => (values += 1));
+            });
+            (0, __1.effect)(() => {
+                entries = 0;
+                Object.entries(store).forEach(() => (entries += 1));
+            });
+            (0, vitest_1.expect)(keys).to.equal(2);
+            (0, vitest_1.expect)(values).to.equal(2);
+            (0, vitest_1.expect)(entries).to.equal(2);
+            store.c = 0;
+            (0, vitest_1.expect)(keys).to.equal(3);
+            (0, vitest_1.expect)(values).to.equal(3);
+            (0, vitest_1.expect)(entries).to.equal(3);
+            delete store.a;
+            (0, vitest_1.expect)(keys).to.equal(2);
+            (0, vitest_1.expect)(values).to.equal(2);
+            (0, vitest_1.expect)(entries).to.equal(2);
+        });
+        (0, vitest_1.it)("should subscribe to changes to for..of loops", () => {
+            const store = (0, index_1.deepSignal)([0, 0]);
+            let sum = 0;
+            (0, __1.effect)(() => {
+                sum = 0;
+                for (const _ of store) {
+                    sum += 1;
+                }
+            });
+            (0, vitest_1.expect)(sum).to.equal(2);
+            store.push(0);
+            (0, vitest_1.expect)(sum).to.equal(3);
+            store.splice(0, 1);
+            (0, vitest_1.expect)(sum).to.equal(2);
+        });
+        (0, vitest_1.it)("should subscribe to implicit changes in array items", () => {
+            const store = (0, index_1.deepSignal)(["foo", "bar"]);
+            let x = "";
+            (0, __1.effect)(() => {
+                x = store.join(" ");
+                console.log("joined", x);
+            });
+            (0, vitest_1.expect)(x).to.equal("foo bar");
+            store.push("baz");
+            (0, vitest_1.expect)(x).to.equal("foo bar baz");
+            store.splice(0, 1);
+            (0, vitest_1.expect)(x).to.equal("bar baz");
+            store.splice(1, 1, "bam");
+            (0, vitest_1.expect)(x).to.equal("bar bam");
+        });
+        (0, vitest_1.it)("should subscribe to changes when deleting properties", () => {
+            let x, y;
+            (0, __1.effect)(() => {
+                x = store.a;
+            });
+            (0, __1.effect)(() => {
+                y = store.nested.b;
+            });
+            (0, vitest_1.expect)(x).to.equal(1);
+            delete store.a;
+            (0, vitest_1.expect)(x).to.equal(undefined);
+            (0, vitest_1.expect)(y).to.equal(2);
+            delete store.nested.b;
+            (0, vitest_1.expect)(y).to.equal(undefined);
+        });
+        (0, vitest_1.it)("should subscribe to changes when mutating objects", () => {
+            let x, y;
+            const store = (0, index_1.deepSignal)({
+                b: [
+                    { id: 1, nested: { id: 1 } },
+                    { id: 2, nested: { id: 2 } },
+                ],
+            });
+            (0, __1.effect)(() => {
+                x = store.a?.id;
+            });
+            (0, __1.effect)(() => {
+                y = store.a?.nested.id;
+            });
+            (0, vitest_1.expect)(x).to.equal(undefined);
+            (0, vitest_1.expect)(y).to.equal(undefined);
+            store.a = store.b[0];
+            (0, vitest_1.expect)(x).to.equal(1);
+            (0, vitest_1.expect)(y).to.equal(1);
+            store.a = store.b[1];
+            (0, vitest_1.expect)(x).to.equal(2);
+            (0, vitest_1.expect)(y).to.equal(2);
+            store.a = undefined;
+            (0, vitest_1.expect)(x).to.equal(undefined);
+            (0, vitest_1.expect)(y).to.equal(undefined);
+            store.a = store.b[1];
+            (0, vitest_1.expect)(x).to.equal(2);
+            (0, vitest_1.expect)(y).to.equal(2);
+        });
+        (0, vitest_1.it)("should trigger effects after mutations happen", () => {
+            let x;
+            (0, __1.effect)(() => {
+                x = store.a;
+            });
+            (0, vitest_1.expect)(x).to.equal(1);
+            store.a = 11;
+            (0, vitest_1.expect)(x).to.equal(11);
+        });
+        (0, vitest_1.it)("should subscribe corretcly from getters", () => {
+            let x;
+            const store = (0, index_1.deepSignal)({
+                counter: 1,
+                get double() {
+                    return store.counter * 2;
+                },
+            });
+            (0, __1.effect)(() => (x = store.double));
+            (0, vitest_1.expect)(x).to.equal(2);
+            store.counter = 2;
+            (0, vitest_1.expect)(x).to.equal(4);
+        });
+        (0, vitest_1.it)("should subscribe corretcly from getters returning other parts of the store", () => {
+            let data;
+            const store = (0, index_1.deepSignal)({
+                switch: "a",
+                a: { data: "a" },
+                b: { data: "b" },
+                get aOrB() {
+                    return store.switch === "a" ? store.a : store.b;
+                },
+            });
+            (0, __1.effect)(() => (data = store.aOrB.data));
+            (0, vitest_1.expect)(data).to.equal("a");
+            store.switch = "b";
+            (0, vitest_1.expect)(data).to.equal("b");
+        });
+        (0, vitest_1.it)("should be able to reset values with Object.assign and still react to changes", () => {
+            const initialNested = { ...nested };
+            const initialState = { ...state, nested: initialNested };
+            let a, b;
+            (0, __1.effect)(() => {
+                a = store.a;
+            });
+            (0, __1.effect)(() => {
+                b = store.nested.b;
+            });
+            store.a = 2;
+            store.nested.b = 3;
+            (0, vitest_1.expect)(a).to.equal(2);
+            (0, vitest_1.expect)(b).to.equal(3);
+            Object.assign(store, initialState);
+            (0, vitest_1.expect)(a).to.equal(1);
+            (0, vitest_1.expect)(b).to.equal(2);
+        });
+    });
+    (0, vitest_1.describe)("refs", () => {
+        (0, vitest_1.it)("should change if children changed", async () => {
+            const signalObj = (0, index_1.deepSignal)({
+                primitive: 1,
+                nestedObject: { primitive: 2 },
+                nestedSetOfPrimitives: new Set([1, 2, "three"]),
+                nestedSetOfObjects: new Set([
+                    { "@id": "obj1", primitive: true },
+                    { "@id": "obj2", primitive: "false" },
+                ]),
+                nestedArrayOfPrimitives: [1, 2, "three"],
+                nestedArrayOfObjects: [
+                    { "@id": "obj1", primitive: true },
+                    { "@id": "obj2", primitive: "false" },
+                ],
+            });
+            // Capture initial references
+            let no = signalObj.nestedObject;
+            let nop = signalObj.nestedObject.primitive;
+            let nsop = signalObj.nestedSetOfPrimitives;
+            let nsoo = signalObj.nestedSetOfObjects;
+            let [nsoo1, nsoo2] = [...signalObj.nestedSetOfObjects];
+            let naop = signalObj.nestedArrayOfPrimitives;
+            let naoo = signalObj.nestedArrayOfObjects;
+            let [naoo1, naoo2] = signalObj.nestedArrayOfObjects;
+            // Mutate root primitive - should not affect nested proxies
+            signalObj.primitive = 2;
+            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
+            (0, vitest_1.expect)(signalObj.nestedObject.primitive).toBe(nop);
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            // Mutate nested object primitive - should replace nestedObject proxy
+            signalObj.nestedObject.primitive = 3;
+            (0, vitest_1.expect)(signalObj.nestedObject.primitive).toBe(3);
+            (0, vitest_1.expect)(signalObj.nestedObject).not.toBe(no);
+            no = signalObj.nestedObject;
+            // Unrelated proxies should remain the same
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            // Mutate Set of primitives - should replace the Set proxy
+            signalObj.nestedSetOfPrimitives.add(4);
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).not.toBe(nsop);
+            nsop = signalObj.nestedSetOfPrimitives;
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives.has(4)).toBe(true);
+            // Unrelated proxies should remain the same
+            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
+            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            // Mutate object inside Set - should replace Set proxy and the object proxy
+            nsoo1.primitive = false;
+            (0, vitest_1.expect)([...signalObj.nestedSetOfObjects][1]).toBe(nsoo2);
+            (0, vitest_1.expect)([...signalObj.nestedSetOfObjects][0]).not.toBe(nsoo1);
+            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).not.toBe(nsoo);
+            nsoo = signalObj.nestedSetOfObjects;
+            [nsoo1, nsoo2] = [...signalObj.nestedSetOfObjects];
+            // Unrelated proxies should remain the same
+            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            // Mutate array of primitives - should replace the array proxy
+            signalObj.nestedArrayOfPrimitives.push(4);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).not.toBe(naop);
+            naop = signalObj.nestedArrayOfPrimitives;
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives.length).toBe(4);
+            // Unrelated proxies should remain the same
+            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).toBe(naoo);
+            // Mutate object inside array - should replace array proxy and the object proxy
+            naoo1.primitive = false;
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects[0]).not.toBe(naoo1);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects[1]).toBe(naoo2);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfObjects).not.toBe(naoo);
+            naoo = signalObj.nestedArrayOfObjects;
+            [naoo1, naoo2] = signalObj.nestedArrayOfObjects;
+            // Unrelated proxies should remain the same
+            (0, vitest_1.expect)(signalObj.nestedObject).toBe(no);
+            (0, vitest_1.expect)(signalObj.nestedSetOfPrimitives).toBe(nsop);
+            (0, vitest_1.expect)(signalObj.nestedSetOfObjects).toBe(nsoo);
+            (0, vitest_1.expect)(signalObj.nestedArrayOfPrimitives).toBe(naop);
+        });
+        (0, vitest_1.it)("should return the same proxy if initialized more than once", () => {
+            const state = {};
+            const store1 = (0, index_1.deepSignal)(state);
+            const store2 = (0, index_1.deepSignal)(state);
+            (0, vitest_1.expect)(store1).to.equal(store2);
+        });
+    });
+    (0, vitest_1.describe)("unsupported data structures", () => {
+        (0, vitest_1.it)("should throw when trying to deepsignal a class instance", () => {
+            class MyClass {
+            }
+            const obj = new MyClass();
+            (0, vitest_1.expect)(() => (0, index_1.deepSignal)(obj)).to.throw();
+        });
+        (0, vitest_1.it)("should not wrap a class instance", () => {
+            class MyClass {
+            }
+            const obj = new MyClass();
+            const store = (0, index_1.deepSignal)({ obj });
+            (0, vitest_1.expect)(store.obj).to.equal(obj);
+        });
+        (0, vitest_1.it)("should not wrap built-ins in proxies", () => {
+            window.MyClass = class MyClass {
+            };
+            const obj = new window.MyClass();
+            const store = (0, index_1.deepSignal)({ obj });
+            (0, vitest_1.expect)(store.obj).to.equal(obj);
+        });
+        // it("should not wrap elements in proxies", () => {
+        // 	const el = window.document.createElement("div");
+        // 	const store = deepSignal({ el });
+        // 	expect(store.el).to.equal(el);
+        // });
+        (0, vitest_1.it)("should wrap global objects", () => {
+            window.obj = { b: 2 };
+            const store = (0, index_1.deepSignal)(window.obj);
+            (0, vitest_1.expect)(store).to.not.equal(window.obj);
+            (0, vitest_1.expect)(store).to.deep.equal({ b: 2 });
+            (0, vitest_1.expect)(store.b).to.equal(2);
+        });
+        (0, vitest_1.it)("should not wrap dates", () => {
+            const date = new Date();
+            const store = (0, index_1.deepSignal)({ date });
+            (0, vitest_1.expect)(store.date).to.equal(date);
+        });
+        (0, vitest_1.it)("should not wrap regular expressions", () => {
+            const regex = new RegExp("");
+            const store = (0, index_1.deepSignal)({ regex });
+            (0, vitest_1.expect)(store.regex).to.equal(regex);
+        });
+        (0, vitest_1.it)("should not wrap Map", () => {
+            const map = new Map();
+            const store = (0, index_1.deepSignal)({ map });
+            (0, vitest_1.expect)(store.map).to.equal(map);
+        });
+        (0, vitest_1.it)("should wrap Set and emit patches on structural changes", () => {
+            const set = new Set([1]);
+            const store = (0, index_1.deepSignal)({ set });
+            // The Set itself should be proxied (different reference)
+            (0, vitest_1.expect)(store.set).to.not.equal(set);
+            // Size observable via manual mutation + patch emission (indirectly validated in watchPatches Set test)
+            store.set.add(2);
+            store.set.delete(1);
+            (0, vitest_1.expect)(store.set.has(2)).to.equal(true);
+        });
+        (0, vitest_1.it)("should expose reactive Set size without throwing", () => {
+            const store = (0, index_1.deepSignal)({ set: new Set([1, 2]) });
+            let size = 0;
+            (0, __1.effect)(() => {
+                size = store.set.size;
+            });
+            (0, vitest_1.expect)(store.set.size).to.equal(2);
+            (0, vitest_1.expect)(size).to.equal(2);
+            store.set.add(3);
+            (0, vitest_1.expect)(store.set.size).to.equal(3);
+            (0, vitest_1.expect)(size).to.equal(3);
+            store.set.delete(1);
+            (0, vitest_1.expect)(store.set.size).to.equal(2);
+            (0, vitest_1.expect)(size).to.equal(2);
+        });
+    });
+    (0, vitest_1.describe)("symbols", () => {
+        (0, vitest_1.it)("should observe symbols", () => {
+            const key = Symbol("key");
+            let x;
+            const store = (0, index_1.deepSignal)({});
+            (0, __1.effect)(() => (x = store[key]));
+            (0, vitest_1.expect)(store[key]).to.equal(undefined);
+            (0, vitest_1.expect)(x).to.equal(undefined);
+            store[key] = true;
+            (0, vitest_1.expect)(store[key]).to.equal(true);
+            (0, vitest_1.expect)(x).to.equal(true);
+        });
+        (0, vitest_1.it)("should not observe well-known symbols", () => {
+            const key = Symbol.isConcatSpreadable;
+            let x;
+            const state = (0, index_1.deepSignal)({});
+            (0, __1.effect)(() => (x = state[key]));
+            (0, vitest_1.expect)(state[key]).to.equal(undefined);
+            (0, vitest_1.expect)(x).to.equal(undefined);
+            state[key] = true;
+            (0, vitest_1.expect)(state[key]).to.equal(true);
+            (0, vitest_1.expect)(x).to.equal(undefined);
+        });
+    });
+    (0, vitest_1.describe)("shallow", () => {
+        (0, vitest_1.it)("should not proxy shallow objects", () => {
+            const shallowObj1 = { a: 1 };
+            let shallowObj2 = { b: 2 };
+            const deepObj = { c: 3 };
+            shallowObj2 = (0, index_1.shallow)(shallowObj2);
+            const store = (0, index_1.deepSignal)({
+                shallowObj1: (0, index_1.shallow)(shallowObj1),
+                shallowObj2,
+                deepObj,
+            });
+            (0, vitest_1.expect)(store.shallowObj1.a).to.equal(1);
+            (0, vitest_1.expect)(store.shallowObj2.b).to.equal(2);
+            (0, vitest_1.expect)(store.deepObj.c).to.equal(3);
+            (0, vitest_1.expect)(store.shallowObj1).to.equal(shallowObj1);
+            (0, vitest_1.expect)(store.shallowObj2).to.equal(shallowObj2);
+            (0, vitest_1.expect)(store.deepObj).to.not.equal(deepObj);
+        });
+        (0, vitest_1.it)("should not proxy shallow objects if shallow is called on the reference before accessing the property", () => {
+            const shallowObj = { a: 1 };
+            const deepObj = { c: 3 };
+            const store = (0, index_1.deepSignal)({ shallowObj, deepObj });
+            (0, index_1.shallow)(shallowObj);
+            (0, vitest_1.expect)(store.shallowObj.a).to.equal(1);
+            (0, vitest_1.expect)(store.deepObj.c).to.equal(3);
+            (0, vitest_1.expect)(store.shallowObj).to.equal(shallowObj);
+            (0, vitest_1.expect)(store.deepObj).to.not.equal(deepObj);
+        });
+        (0, vitest_1.it)("should observe changes in the shallow object if the reference changes", () => {
+            const obj = { a: 1 };
+            const shallowObj = (0, index_1.shallow)(obj);
+            const store = (0, index_1.deepSignal)({ shallowObj });
+            let x;
+            (0, __1.effect)(() => {
+                x = store.shallowObj.a;
+            });
+            (0, vitest_1.expect)(x).to.equal(1);
+            store.shallowObj = (0, index_1.shallow)({ a: 2 });
+            (0, vitest_1.expect)(x).to.equal(2);
+        });
+        (0, vitest_1.it)("should stop observing changes in the shallow object if the reference changes and it's not shallow anymore", () => {
+            const obj = { a: 1 };
+            const shallowObj = (0, index_1.shallow)(obj);
+            const store = (0, index_1.deepSignal)({ obj: shallowObj });
+            let x;
+            (0, __1.effect)(() => {
+                x = store.obj.a;
+            });
+            (0, vitest_1.expect)(x).to.equal(1);
+            store.obj = { a: 2 };
+            (0, vitest_1.expect)(x).to.equal(2);
+            store.obj.a = 3;
+            (0, vitest_1.expect)(x).to.equal(3);
+        });
+        (0, vitest_1.it)("should not observe changes in the props of the shallow object", () => {
+            const obj = { a: 1 };
+            const shallowObj = (0, index_1.shallow)(obj);
+            const store = (0, index_1.deepSignal)({ shallowObj });
+            let x;
+            (0, __1.effect)(() => {
+                x = store.shallowObj.a;
+            });
+            (0, vitest_1.expect)(x).to.equal(1);
+            store.shallowObj.a = 2;
+            (0, vitest_1.expect)(x).to.equal(1);
+        });
+    });
+});