@ersbeth/picoflow 2.0.1 → 2.0.3

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

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