@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/reactivity/nodes/collections/flowArray.scalars.test.ts

@@ -0,0 +1,961 @@
+import { describe, expect, it, vi } from "vitest";
+import { array, subscribe } from "~";
+
+describe("FlowArray", () => {
+    describe("unit", () => {
+        describe("initialization", () => {
+            it("should initialize with provided values", async () => {
+                const $array = array([1, 2, 3]);
+
+                expect(await $array.pick()).toEqual([1, 2, 3]);
+            });
+
+            it("should initialize with empty array when no value provided", async () => {
+                const $array = array<number>();
+
+                expect(await $array.pick()).toEqual([]);
+            });
+        });
+
+        describe("disposal", () => {
+            it("should have disposed property set to false initially and true after disposal", () => {
+                const $array = array([1, 2, 3]);
+                expect($array.disposed).toBe(false);
+                $array.dispose();
+                expect($array.disposed).toBe(true);
+            });
+
+            it("should throw error when disposed twice", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.dispose()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when pick is called after disposal", async () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                await expect($array.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when set is called after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.set([1])).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when update is called after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.update(0, 3)).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when push is called after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.push(3)).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when pop is called after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.pop()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when unshift is called after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.unshift(3)).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when shift is called after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.shift()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when splice is called after disposal", () => {
+                const $array = array<number>([0, 1, 2, 3, 4]);
+                $array.dispose();
+                expect(() => $array.splice(1, 2)).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw when clear is called after disposal", () => {
+                const $array = array<number>([0, 1, 2, 3, 4]);
+                $array.dispose();
+                expect(() => $array.clear()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+        });
+
+        describe("length", () => {
+            it("should return correct length", () => {
+                const $array = array([1, 2, 3]);
+                expect($array.length).toBe(3);
+            });
+
+            it("should return zero for empty array", () => {
+                const $array = array<number>([]);
+                expect($array.length).toBe(0);
+            });
+
+            it("should throw when length is accessed after disposal", () => {
+                const $array = array([1, 2, 3]);
+                $array.dispose();
+                expect(() => $array.length).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should update length when array is modified", () => {
+                const $array = array<number>([]);
+                expect($array.length).toBe(0);
+
+                $array.push(1);
+                expect($array.length).toBe(1);
+
+                $array.push(2);
+                expect($array.length).toBe(2);
+
+                $array.pop();
+                expect($array.length).toBe(1);
+
+                $array.unshift(0);
+                expect($array.length).toBe(2);
+
+                $array.shift();
+                expect($array.length).toBe(1);
+
+                $array.clear();
+                expect($array.length).toBe(0);
+            });
+        });
+
+        describe("set", () => {
+            it("should update array when set is called", async () => {
+                const $array = array([0, 1, 2]);
+                expect(await $array.pick()).toEqual([0, 1, 2]);
+
+                $array.set([1, 2, 3]);
+                expect(await $array.pick()).toEqual([1, 2, 3]);
+            });
+        });
+
+        describe("update", () => {
+            it("should update item at specific index", async () => {
+                const $array = array([0, 1, 2]);
+                expect(await $array.pick()).toEqual([0, 1, 2]);
+
+                $array.update(0, 1);
+                expect(await $array.pick()).toEqual([1, 1, 2]);
+
+                $array.update(1, 2);
+                expect(await $array.pick()).toEqual([1, 2, 2]);
+
+                $array.update(2, 3);
+                expect(await $array.pick()).toEqual([1, 2, 3]);
+            });
+
+            it("should throw when update is called with negative index", () => {
+                const $array = array([1, 2, 3]);
+                expect(() => $array.update(-1, 0)).toThrow("[PicoFlow] Index out of bounds");
+            });
+
+            it("should throw when update is called with index >= length", () => {
+                const $array = array([1, 2, 3]);
+                expect(() => $array.update(3, 0)).toThrow("[PicoFlow] Index out of bounds");
+                expect(() => $array.update(10, 0)).toThrow("[PicoFlow] Index out of bounds");
+            });
+
+            it("should handle boundary indices correctly", async () => {
+                const $array = array([0, 1, 2]);
+                $array.update(0, 10);
+                expect(await $array.pick()).toEqual([10, 1, 2]);
+
+                $array.update(2, 20);
+                expect(await $array.pick()).toEqual([10, 1, 20]);
+            });
+        });
+
+        describe("push", () => {
+            it("should append item to end of array", async () => {
+                const $array = array<number>([]);
+                expect(await $array.pick()).toEqual([]);
+
+                $array.push(0);
+                expect(await $array.pick()).toEqual([0]);
+
+                $array.push(1);
+                expect(await $array.pick()).toEqual([0, 1]);
+
+                $array.push(2);
+                expect(await $array.pick()).toEqual([0, 1, 2]);
+            });
+
+            it("should handle operations on empty array", () => {
+                const $array = array<number>([]);
+                expect($array.length).toBe(0);
+                $array.push(1);
+                expect($array.length).toBe(1);
+            });
+        });
+
+        describe("pop", () => {
+            it("should remove last item from array", async () => {
+                const $array = array([0, 1, 2]);
+                expect(await $array.pick()).toEqual([0, 1, 2]);
+
+                $array.pop();
+                expect(await $array.pick()).toEqual([0, 1]);
+
+                $array.pop();
+                expect(await $array.pick()).toEqual([0]);
+
+                $array.pop();
+                expect(await $array.pick()).toEqual([]);
+            });
+
+            it("should handle operations on empty array", () => {
+                const $array = array<number>([]);
+                expect($array.length).toBe(0);
+                $array.pop();
+                expect($array.length).toBe(0);
+            });
+        });
+
+        describe("unshift", () => {
+            it("should insert item at beginning of array", async () => {
+                const $array = array<number>([]);
+                expect(await $array.pick()).toEqual([]);
+
+                $array.unshift(0);
+                expect(await $array.pick()).toEqual([0]);
+
+                $array.unshift(1);
+                expect(await $array.pick()).toEqual([1, 0]);
+
+                $array.unshift(2);
+                expect(await $array.pick()).toEqual([2, 1, 0]);
+            });
+        });
+
+        describe("shift", () => {
+            it("should remove first item from array", async () => {
+                const $array = array([0, 1, 2]);
+                expect(await $array.pick()).toEqual([0, 1, 2]);
+
+                $array.shift();
+                expect(await $array.pick()).toEqual([1, 2]);
+
+                $array.shift();
+                expect(await $array.pick()).toEqual([2]);
+
+                $array.shift();
+                expect(await $array.pick()).toEqual([]);
+            });
+
+            it("should handle operations on empty array", () => {
+                const $array = array<number>([]);
+                expect($array.length).toBe(0);
+                $array.shift();
+                expect($array.length).toBe(0);
+            });
+        });
+
+        describe("splice", () => {
+            it("should remove items from array", async () => {
+                const $array = array<number>([0, 1, 2, 3, 4]);
+                expect(await $array.pick()).toEqual([0, 1, 2, 3, 4]);
+
+                $array.splice(1, 2);
+                expect(await $array.pick()).toEqual([0, 3, 4]);
+            });
+
+            it("should insert items into array", async () => {
+                const $array = array<number>([0, 1, 2, 3, 4]);
+                $array.splice(1, 0, 10, 11);
+                expect(await $array.pick()).toEqual([0, 10, 11, 1, 2, 3, 4]);
+            });
+
+            it("should replace items in array", async () => {
+                const $array = array<number>([0, 1, 2, 3, 4]);
+                $array.splice(1, 2, 10, 11);
+                expect(await $array.pick()).toEqual([0, 10, 11, 3, 4]);
+            });
+        });
+
+        describe("clear", () => {
+            it("should remove all items from array", async () => {
+                const $array = array<number>([0, 1, 2, 3, 4]);
+                expect(await $array.pick()).toEqual([0, 1, 2, 3, 4]);
+
+                $array.clear();
+                expect(await $array.pick()).toEqual([]);
+            });
+        });
+
+        describe("$lastAction", () => {
+            describe("set action", () => {
+                it("should initialize $lastAction with set action on creation", async () => {
+                    const $array = array([1, 2, 3]);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "set",
+                        setItems: [1, 2, 3],
+                        clearedItems: [],
+                    });
+                });
+
+                it("should update $lastAction with set action when set is called", async () => {
+                    const $array = array([0, 1, 2]);
+                    $array.set([1, 2, 3]);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "set",
+                        setItems: [1, 2, 3],
+                        clearedItems: [0, 1, 2],
+                    });
+                });
+
+                it("should have correct structure for set action (setItems and clearedItems)", async () => {
+                    const $array = array([1, 2, 3]);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "set");
+                    if (action.type === "set") {
+                        expect(action).toHaveProperty("setItems");
+                        expect(action).toHaveProperty("clearedItems");
+                        expect(Array.isArray(action.setItems)).toBe(true);
+                        expect(Array.isArray(action.clearedItems)).toBe(true);
+                        expect(action.setItems).toEqual([1, 2, 3]);
+                        expect(action.clearedItems).toEqual([]);
+                    }
+                });
+            });
+
+            describe("update action", () => {
+                it("should update $lastAction with update action when update is called", async () => {
+                    const $array = array([0, 1, 2]);
+                    $array.update(1, 10);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "update",
+                        index: 1,
+                        setItem: 10,
+                        clearedItem: 1,
+                    });
+                });
+
+                it("should have correct structure for update action (index, setItem, clearedItem)", async () => {
+                    const $array = array([1, 2, 3]);
+                    $array.update(0, 10);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "update");
+                    if (action.type === "update") {
+                        expect(action).toHaveProperty("index");
+                        expect(action).toHaveProperty("setItem");
+                        expect(action).toHaveProperty("clearedItem");
+                        expect(action.index).toBe(0);
+                        expect(action.setItem).toBe(10);
+                        expect(action.clearedItem).toBe(1);
+                    }
+                });
+            });
+
+            describe("push action", () => {
+                it("should update $lastAction with push action when push is called", async () => {
+                    const $array = array<number>([]);
+                    $array.push(42);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "push",
+                        addedItem: 42,
+                    });
+                });
+
+                it("should have correct structure for push action (addedItem)", async () => {
+                    const $array = array<number>([]);
+                    $array.push(100);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "push");
+                    if (action.type === "push") {
+                        expect(action).toHaveProperty("addedItem");
+                        expect(action.addedItem).toBe(100);
+                    }
+                });
+            });
+
+            describe("pop action", () => {
+                it("should update $lastAction with pop action when pop is called", async () => {
+                    const $array = array([1, 2, 3]);
+                    $array.pop();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "pop",
+                        removedItem: 3,
+                    });
+                });
+
+                it("should have correct structure for pop action (removedItem)", async () => {
+                    const $array = array([1, 2, 3]);
+                    $array.pop();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "pop");
+                    if (action.type === "pop") {
+                        expect(action).toHaveProperty("removedItem");
+                        expect(action.removedItem).toBe(3);
+                    }
+                });
+
+                it("should have removedItem undefined when pop is called on empty array", async () => {
+                    const $array = array<number>([]);
+                    $array.pop();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "pop");
+                    if (action.type === "pop") {
+                        expect(action).toHaveProperty("removedItem");
+                        expect(action.removedItem).toBeUndefined();
+                    }
+                });
+            });
+
+            describe("unshift action", () => {
+                it("should update $lastAction with unshift action when unshift is called", async () => {
+                    const $array = array<number>([]);
+                    $array.unshift(42);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "unshift",
+                        addedItem: 42,
+                    });
+                });
+
+                it("should have correct structure for unshift action (addedItem)", async () => {
+                    const $array = array<number>([]);
+                    $array.unshift(200);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "unshift");
+                    if (action.type === "unshift") {
+                        expect(action).toHaveProperty("addedItem");
+                        expect(action.addedItem).toBe(200);
+                    }
+                });
+            });
+
+            describe("shift action", () => {
+                it("should update $lastAction with shift action when shift is called", async () => {
+                    const $array = array([1, 2, 3]);
+                    $array.shift();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "shift",
+                        removedItem: 1,
+                    });
+                });
+
+                it("should have correct structure for shift action (removedItem)", async () => {
+                    const $array = array([1, 2, 3]);
+                    $array.shift();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "shift");
+                    if (action.type === "shift") {
+                        expect(action).toHaveProperty("removedItem");
+                        expect(action.removedItem).toBe(1);
+                    }
+                });
+
+                it("should have removedItem undefined when shift is called on empty array", async () => {
+                    const $array = array<number>([]);
+                    $array.shift();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "shift");
+                    if (action.type === "shift") {
+                        expect(action).toHaveProperty("removedItem");
+                        expect(action.removedItem).toBeUndefined();
+                    }
+                });
+            });
+
+            describe("splice action", () => {
+                it("should update $lastAction with splice action when splice is called", async () => {
+                    const $array = array<number>([0, 1, 2, 3, 4]);
+                    $array.splice(1, 2, 10, 11);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "splice",
+                        start: 1,
+                        deleteCount: 2,
+                        addedItems: [10, 11],
+                        removedItems: [1, 2],
+                    });
+                });
+
+                it("should have correct structure for splice action (start, deleteCount, addedItems, removedItems)", async () => {
+                    const $array = array<number>([0, 1, 2]);
+                    $array.splice(1, 1, 100);
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "splice");
+                    if (action.type === "splice") {
+                        expect(action).toHaveProperty("start");
+                        expect(action).toHaveProperty("deleteCount");
+                        expect(action).toHaveProperty("addedItems");
+                        expect(action).toHaveProperty("removedItems");
+                        expect(action.start).toBe(1);
+                        expect(action.deleteCount).toBe(1);
+                        expect(Array.isArray(action.addedItems)).toBe(true);
+                        expect(Array.isArray(action.removedItems)).toBe(true);
+                        expect(action.addedItems).toEqual([100]);
+                        expect(action.removedItems).toEqual([1]);
+                    }
+                });
+            });
+
+            describe("clear action", () => {
+                it("should update $lastAction with clear action when clear is called", async () => {
+                    const $array = array<number>([0, 1, 2, 3, 4]);
+                    $array.clear();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toEqual({
+                        type: "clear",
+                        clearedItems: [0, 1, 2, 3, 4],
+                    });
+                });
+
+                it("should have correct structure for clear action (clearedItems)", async () => {
+                    const $array = array<number>([1, 2, 3]);
+                    $array.clear();
+                    const action = await $array.$lastAction.pick();
+                    expect(action).toHaveProperty("type", "clear");
+                    if (action.type === "clear") {
+                        expect(action).toHaveProperty("clearedItems");
+                        expect(Array.isArray(action.clearedItems)).toBe(true);
+                        expect(action.clearedItems).toEqual([1, 2, 3]);
+                    }
+                });
+            });
+        });
+
+        describe("edge cases", () => {
+            it("should handle multiple rapid operations", async () => {
+                const $array = array<number>([]);
+                $array.push(1);
+                $array.push(2);
+                $array.push(3);
+                $array.pop();
+                $array.shift();
+                $array.unshift(0);
+                expect(await $array.pick()).toEqual([0, 2]);
+            });
+
+            it("should handle boundary indices correctly", async () => {
+                const $array = array([0, 1, 2]);
+                $array.update(0, 10);
+                $array.update(2, 20);
+                expect(await $array.pick()).toEqual([10, 1, 20]);
+            });
+        });
+    });
+
+    describe("integration", () => {
+        describe("with effects", () => {
+            describe("reactivity", () => {
+                it("should call effect when initialized", async () => {
+                    const $array = array([1, 2, 3]);
+                    const onData = vi.fn();
+                    subscribe((t) => $array.get(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([1, 2, 3]);
+                });
+
+                it("should call effect when updated with set", async () => {
+                    const $array = array<number>([0, 1, 2]);
+                    const onData = vi.fn();
+                    subscribe((t) => $array.get(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1, 2]);
+
+                    $array.set([1, 2, 3]);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([1, 2, 3]);
+                });
+
+                it("should call effect when updated with push/pop", async () => {
+                    const $array = array<number>();
+                    const onData = vi.fn();
+                    subscribe((t) => $array.get(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([]);
+
+                    $array.push(0);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([0]);
+
+                    $array.push(1);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1]);
+
+                    $array.push(2);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1, 2]);
+
+                    $array.pop();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(5));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1]);
+
+                    $array.pop();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(6));
+                    expect(onData).toHaveBeenLastCalledWith([0]);
+
+                    $array.pop();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(7));
+                    expect(onData).toHaveBeenLastCalledWith([]);
+                });
+
+                it("should call effect when updated with unshift/shift", async () => {
+                    const $array = array<number>();
+                    const onData = vi.fn();
+                    subscribe((t) => $array.get(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([]);
+
+                    $array.unshift(0);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([0]);
+
+                    $array.unshift(1);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                    expect(onData).toHaveBeenLastCalledWith([1, 0]);
+
+                    $array.unshift(2);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                    expect(onData).toHaveBeenLastCalledWith([2, 1, 0]);
+
+                    $array.shift();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(5));
+                    expect(onData).toHaveBeenLastCalledWith([1, 0]);
+
+                    $array.shift();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(6));
+                    expect(onData).toHaveBeenLastCalledWith([0]);
+
+                    $array.shift();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(7));
+                    expect(onData).toHaveBeenLastCalledWith([]);
+                });
+
+                it("should call effect when updated with splice", async () => {
+                    const $array = array<number>([0, 1, 2, 3, 4]);
+                    const onData = vi.fn();
+                    subscribe((t) => $array.get(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1, 2, 3, 4]);
+
+                    $array.splice(1, 2);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([0, 3, 4]);
+
+                    $array.splice(1, 0, 1, 2);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1, 2, 3, 4]);
+                });
+
+                it("should call effect when updated with clear", async () => {
+                    const $array = array<number>([0, 1, 2, 3, 4]);
+                    const onData = vi.fn();
+                    subscribe((t) => $array.get(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1, 2, 3, 4]);
+
+                    $array.clear();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([]);
+                });
+            });
+
+            describe("item reactivity", () => {
+                it("should call effect when item is updated", async () => {
+                    const $array = array<number>([0, 1, 2]);
+                    const onData = vi.fn();
+                    const onData0 = vi.fn();
+                    const onData1 = vi.fn();
+                    const onData2 = vi.fn();
+
+                    subscribe((t) => $array.get(t), onData);
+                    subscribe((t) => $array.get(t)[0], onData0);
+                    subscribe((t) => $array.get(t)[1], onData1);
+                    subscribe((t) => $array.get(t)[2], onData2);
+
+                    $array.update(0, 1);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([1, 1, 2]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(2));
+                    expect(onData0).toHaveBeenLastCalledWith(1);
+                    await vi.waitFor(() => expect(onData1).toHaveBeenCalledTimes(2));
+                    expect(onData1).toHaveBeenLastCalledWith(1);
+                    await vi.waitFor(() => expect(onData2).toHaveBeenCalledTimes(2));
+                    expect(onData2).toHaveBeenLastCalledWith(2);
+
+                    $array.update(1, 2);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                    expect(onData).toHaveBeenLastCalledWith([1, 2, 2]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(3));
+                    expect(onData0).toHaveBeenLastCalledWith(1);
+                    await vi.waitFor(() => expect(onData1).toHaveBeenCalledTimes(3));
+                    expect(onData1).toHaveBeenLastCalledWith(2);
+                    await vi.waitFor(() => expect(onData2).toHaveBeenCalledTimes(3));
+                    expect(onData2).toHaveBeenLastCalledWith(2);
+
+                    $array.update(2, 3);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                    expect(onData).toHaveBeenLastCalledWith([1, 2, 3]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(4));
+                    expect(onData0).toHaveBeenLastCalledWith(1);
+                    await vi.waitFor(() => expect(onData1).toHaveBeenCalledTimes(4));
+                    expect(onData1).toHaveBeenLastCalledWith(2);
+                    await vi.waitFor(() => expect(onData2).toHaveBeenCalledTimes(4));
+                    expect(onData2).toHaveBeenLastCalledWith(3);
+                });
+
+                it("should call effect when item is replaced", async () => {
+                    const $array = array<number>([0, 1, 2]);
+                    const onData = vi.fn();
+                    const onData0 = vi.fn();
+
+                    subscribe((t) => $array.get(t), onData);
+                    subscribe((t) => $array.get(t)[0], onData0);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenLastCalledWith([0, 1, 2]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(1));
+                    expect(onData0).toHaveBeenLastCalledWith(0);
+
+                    $array.update(0, 3);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                    expect(onData).toHaveBeenLastCalledWith([3, 1, 2]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(2));
+                    expect(onData0).toHaveBeenLastCalledWith(3);
+
+                    $array.shift();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                    expect(onData).toHaveBeenLastCalledWith([1, 2]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(3));
+                    expect(onData0).toHaveBeenLastCalledWith(1);
+
+                    $array.unshift(4);
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                    expect(onData).toHaveBeenLastCalledWith([4, 1, 2]);
+                    await vi.waitFor(() => expect(onData0).toHaveBeenCalledTimes(4));
+                    expect(onData0).toHaveBeenLastCalledWith(4);
+                });
+            });
+
+            describe("lastAction reactivity", () => {
+                describe("set action", () => {
+                    it("should call effect when $lastAction is updated with set action", async () => {
+                        const $array = array([0, 1, 2]);
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "set",
+                            setItems: [0, 1, 2],
+                            clearedItems: [],
+                        });
+
+                        $array.set([1, 2, 3]);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "set",
+                            setItems: [1, 2, 3],
+                            clearedItems: [0, 1, 2],
+                        });
+                    });
+                });
+
+                describe("update action", () => {
+                    it("should call effect when $lastAction is updated with update action", async () => {
+                        const $array = array([0, 1, 2]);
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                        $array.update(1, 10);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "update",
+                            index: 1,
+                            setItem: 10,
+                            clearedItem: 1,
+                        });
+                    });
+                });
+
+                describe("push action", () => {
+                    it("should call effect when $lastAction is updated with push action", async () => {
+                        const $array = array<number>();
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "set",
+                            setItems: [],
+                            clearedItems: [],
+                        });
+
+                        $array.push(0);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "push",
+                            addedItem: 0,
+                        });
+
+                        $array.push(1);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "push",
+                            addedItem: 1,
+                        });
+                    });
+                });
+
+                describe("pop action", () => {
+                    it("should call effect when $lastAction is updated with pop action", async () => {
+                        const $array = array<number>([0, 1, 2]);
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                        $array.pop();
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "pop",
+                            removedItem: 2,
+                        });
+
+                        $array.pop();
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "pop",
+                            removedItem: 1,
+                        });
+                    });
+                });
+
+                describe("unshift action", () => {
+                    it("should call effect when $lastAction is updated with unshift action", async () => {
+                        const $array = array<number>();
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "set",
+                            setItems: [],
+                            clearedItems: [],
+                        });
+
+                        $array.unshift(0);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "unshift",
+                            addedItem: 0,
+                        });
+
+                        $array.unshift(1);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "unshift",
+                            addedItem: 1,
+                        });
+                    });
+                });
+
+                describe("shift action", () => {
+                    it("should call effect when $lastAction is updated with shift action", async () => {
+                        const $array = array<number>([0, 1, 2]);
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                        $array.shift();
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "shift",
+                            removedItem: 0,
+                        });
+
+                        $array.shift();
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "shift",
+                            removedItem: 1,
+                        });
+                    });
+                });
+
+                describe("splice action", () => {
+                    it("should call effect when $lastAction is updated with splice action", async () => {
+                        const $array = array<number>([0, 1, 2, 3, 4]);
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "set",
+                            setItems: [0, 1, 2, 3, 4],
+                            clearedItems: [],
+                        });
+
+                        $array.splice(1, 2);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "splice",
+                            start: 1,
+                            deleteCount: 2,
+                            addedItems: [],
+                            removedItems: [1, 2],
+                        });
+
+                        $array.splice(1, 0, 1, 2);
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "splice",
+                            start: 1,
+                            deleteCount: 0,
+                            addedItems: [1, 2],
+                            removedItems: [],
+                        });
+                    });
+                });
+
+                describe("clear action", () => {
+                    it("should call effect when $lastAction is updated with clear action", async () => {
+                        const $array = array<number>([0, 1, 2, 3, 4]);
+                        const onData = vi.fn();
+                        subscribe((t) => $array.$lastAction.get(t), onData);
+
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "set",
+                            setItems: [0, 1, 2, 3, 4],
+                            clearedItems: [],
+                        });
+
+                        $array.clear();
+                        await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                        expect(onData).toHaveBeenLastCalledWith({
+                            type: "clear",
+                            clearedItems: [0, 1, 2, 3, 4],
+                        });
+                    });
+                });
+            });
+        });
+    });
+});