@ersbeth/picoflow 2.0.1 → 2.0.3

package/test/reactivity/nodes/collections/flowMap.asyncStates.test.ts

@@ -1,960 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { type FlowStateAsync, map, stateAsync, subscribe } from "~";
-
-describe("FlowMap", () => {
-    describe("unit", () => {
-        describe("initialization", () => {
-            it("should initialize with provided Record of FlowStateAsync values", async () => {
-                const $map = map({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                    key3: stateAsync(Promise.resolve(3)),
-                });
-
-                const values = await Promise.all(Array.from((await $map.pick()).values()).map((value) => value.pick()));
-
-                expect(values).toEqual([1, 2, 3]);
-            });
-
-            it("should initialize with provided Map of FlowStateAsync values", async () => {
-                const $value1 = stateAsync(Promise.resolve(1));
-                const $value2 = stateAsync(Promise.resolve(2));
-                const initialMap = new Map([
-                    ["key1", $value1],
-                    ["key2", $value2],
-                ]);
-                const $map = map(initialMap);
-
-                expect(Array.from((await $map.pick()).entries())).toEqual([
-                    ["key1", $value1],
-                    ["key2", $value2],
-                ]);
-            });
-
-            it("should initialize with empty map when no value provided", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-
-                expect(Array.from((await $map.pick()).entries())).toEqual([]);
-                expect((await $map.pick()).size).toBe(0);
-            });
-
-            it("should initialize $lastAction with set action on creation", async () => {
-                const $value1 = stateAsync(Promise.resolve(1));
-                const $value2 = stateAsync(Promise.resolve(2));
-                const $map = map({
-                    key1: $value1,
-                    key2: $value2,
-                });
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("set");
-                if (action.type === "set") {
-                    expect(action.setMap.size).toBe(2);
-                    expect(action.setMap.get("key1")).toBe($value1);
-                    expect(action.setMap.get("key2")).toBe($value2);
-                }
-            });
-
-            it("should initialize $lastAction with empty map when no value provided", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("set");
-                if (action.type === "set") {
-                    expect(action.setMap.size).toBe(0);
-                }
-            });
-        });
-
-        describe("disposal", () => {
-            it("should have disposed property set to false initially and true after disposal", () => {
-                const $map = map({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                });
-                expect($map.disposed).toBe(false);
-                $map.dispose();
-                expect($map.disposed).toBe(true);
-            });
-
-            it("should throw error when disposed twice", () => {
-                const $map = map({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                });
-                $map.dispose();
-                expect(() => $map.dispose()).toThrow("[PicoFlow] Primitive is disposed");
-            });
-
-            it("should throw when pick is called after disposal", async () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                    key3: stateAsync(Promise.resolve(3)),
-                });
-                $map.dispose();
-                await expect($map.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
-            });
-
-            it("should throw when set is called after disposal", () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                });
-                $map.dispose();
-                expect(() => $map.set(new Map([["key2", stateAsync(Promise.resolve(2))]]))).toThrow(
-                    "[PicoFlow] Primitive is disposed",
-                );
-            });
-
-            it("should throw when add is called after disposal", () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.dispose();
-                expect(() => $map.add("key1", stateAsync(Promise.resolve(2)))).toThrow(
-                    "[PicoFlow] Primitive is disposed",
-                );
-            });
-
-            it("should throw when update is called after disposal", () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.dispose();
-                expect(() => $map.update("key1", stateAsync(Promise.resolve(2)))).toThrow(
-                    "[PicoFlow] Primitive is disposed",
-                );
-            });
-
-            it("should throw when delete is called after disposal", () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                    key3: stateAsync(Promise.resolve(3)),
-                });
-                $map.dispose();
-                expect(() => $map.delete("key1")).toThrow("[PicoFlow] Primitive is disposed");
-            });
-
-            it("should throw when clear is called after disposal", () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                });
-                $map.dispose();
-                expect(() => $map.clear()).toThrow("[PicoFlow] Primitive is disposed");
-            });
-
-            it("should dispose values when FlowMap is disposed", () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const $value1 = stateAsync(Promise.resolve(1));
-                const $value2 = stateAsync(Promise.resolve(2));
-                const $value3 = stateAsync(Promise.resolve(3));
-
-                $map.add("key1", $value1);
-                $map.add("key2", $value2);
-                $map.add("key3", $value3);
-
-                expect($value1.disposed).toBe(false);
-                expect($value2.disposed).toBe(false);
-                expect($value3.disposed).toBe(false);
-
-                $map.dispose();
-
-                expect($value1.disposed).toBe(true);
-                expect($value2.disposed).toBe(true);
-                expect($value3.disposed).toBe(true);
-            });
-
-            it("should dispose values with provided options when FlowMap is disposed", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const $value1 = stateAsync(Promise.resolve(1));
-                const $value2 = stateAsync(Promise.resolve(2));
-                const onData = vi.fn((_value: number) => undefined);
-
-                $map.add("key1", $value1);
-                $map.add("key2", $value2);
-
-                const $effect = subscribe((t) => $value1.get(t), onData);
-
-                await vi.waitFor(() => expect($effect.disposed).toBe(false));
-
-                $map.dispose();
-
-                expect($value1.disposed).toBe(true);
-                expect($value2.disposed).toBe(true);
-                expect($effect.disposed).toBe(false);
-
-                $effect.dispose();
-            });
-
-            it("should handle non-disposable values gracefully", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.add("key2", stateAsync(Promise.resolve(2)));
-                $map.add("key3", stateAsync(Promise.resolve(3)));
-
-                expect((await $map.pick()).size).toBe(3);
-
-                expect(() => $map.dispose()).not.toThrow();
-            });
-        });
-
-        describe("set", () => {
-            it("should replace entire map when set is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                });
-                const $newValue1 = stateAsync(Promise.resolve(3));
-                const $newValue2 = stateAsync(Promise.resolve(4));
-                const newMap = new Map([
-                    ["key3", $newValue1],
-                    ["key4", $newValue2],
-                ]);
-
-                $map.set(newMap);
-                expect(Array.from((await $map.pick()).entries())).toEqual([
-                    ["key3", $newValue1],
-                    ["key4", $newValue2],
-                ]);
-            });
-
-            it("should update $lastAction with set action when set is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                });
-                const $newValue1 = stateAsync(Promise.resolve(3));
-                const $newValue2 = stateAsync(Promise.resolve(4));
-                const newMap = new Map([
-                    ["key3", $newValue1],
-                    ["key4", $newValue2],
-                ]);
-
-                $map.set(newMap);
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("set");
-                if (action.type === "set") {
-                    expect(action.setMap).toBe(newMap);
-                    expect(action.clearedMap).toBeInstanceOf(Map);
-                }
-            });
-        });
-
-        describe("add", () => {
-            it("should add key-value pair to map", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                expect(await (await $map.pick()).get("key1")?.pick()).toBe(1);
-                expect((await $map.pick()).size).toBe(1);
-            });
-
-            it("should add multiple keys successively", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.add("key2", stateAsync(Promise.resolve(2)));
-                $map.add("key3", stateAsync(Promise.resolve(3)));
-
-                expect((await $map.pick()).size).toBe(3);
-                expect(await (await $map.pick()).get("key1")?.pick()).toBe(1);
-                expect(await (await $map.pick()).get("key2")?.pick()).toBe(2);
-                expect(await (await $map.pick()).get("key3")?.pick()).toBe(3);
-            });
-
-            it("should throw when key already exists", () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                expect(() => $map.add("key1", stateAsync(Promise.resolve(2)))).toThrow("[PicoFlow] Key already exists");
-            });
-
-            it("should update $lastAction with add action when add is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const $value = stateAsync(Promise.resolve(1));
-                $map.add("key1", $value);
-                const action = await $map.$lastAction.pick();
-                expect(action).toEqual({
-                    type: "add",
-                    key: "key1",
-                    addedValue: $value,
-                });
-            });
-
-            it("should have FlowStateAsync value in $lastAction when add is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const $value = stateAsync(Promise.resolve(100));
-                $map.add("key1", $value);
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("add");
-                if (action.type === "add") {
-                    expect(action.addedValue).toBe($value);
-                    expect(await action.addedValue.pick()).toBe(100);
-                }
-            });
-
-            it("should trigger reactivity when add is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const onData = vi.fn();
-                subscribe((t) => $map.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-            });
-        });
-
-        describe("update", () => {
-            it("should update existing key-value pair", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-
-                const $newValue = stateAsync(Promise.resolve(2));
-                $map.update("key1", $newValue);
-                expect(await (await $map.pick()).get("key1")?.pick()).toBe(2);
-            });
-
-            it("should update multiple keys successively", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.add("key2", stateAsync(Promise.resolve(2)));
-
-                $map.update("key1", stateAsync(Promise.resolve(10)));
-                $map.update("key2", stateAsync(Promise.resolve(20)));
-
-                expect(await (await $map.pick()).get("key1")?.pick()).toBe(10);
-                expect(await (await $map.pick()).get("key2")?.pick()).toBe(20);
-            });
-
-            it("should throw when key does not exist", () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                expect(() => $map.update("key1", stateAsync(Promise.resolve(1)))).toThrow(
-                    "[PicoFlow] Key does not exist",
-                );
-            });
-
-            it("should update $lastAction with update action when update is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                const $newValue = stateAsync(Promise.resolve(2));
-                $map.update("key1", $newValue);
-                const action = await $map.$lastAction.pick();
-                expect(action).toEqual({
-                    type: "update",
-                    key: "key1",
-                    setValue: $newValue,
-                    clearedValue: expect.any(Object),
-                });
-            });
-
-            it("should have FlowStateAsync value in $lastAction when update is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                const $newValue = stateAsync(Promise.resolve(200));
-                $map.update("key1", $newValue);
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("update");
-                if (action.type === "update") {
-                    expect(action.setValue).toBe($newValue);
-                    expect(await action.setValue.pick()).toBe(200);
-                }
-            });
-
-            it("should trigger reactivity when update is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                const onData = vi.fn();
-                subscribe((t) => $map.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $map.update("key1", stateAsync(Promise.resolve(2)));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-            });
-        });
-
-        describe("delete", () => {
-            it("should delete key from map", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.add("key2", stateAsync(Promise.resolve(2)));
-
-                $map.delete("key1");
-                expect(await (await $map.pick()).get("key1")?.pick()).toBe(undefined);
-                expect(await (await $map.pick()).get("key2")?.pick()).toBe(2);
-                expect((await $map.pick()).size).toBe(1);
-            });
-
-            it("should delete multiple keys successively", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.add("key2", stateAsync(Promise.resolve(2)));
-                $map.add("key3", stateAsync(Promise.resolve(3)));
-
-                $map.delete("key1");
-                $map.delete("key2");
-
-                expect((await $map.pick()).size).toBe(1);
-                expect(await (await $map.pick()).get("key3")?.pick()).toBe(3);
-            });
-
-            it("should throw when key does not exist", () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                expect(() => $map.delete("key1")).toThrow("[PicoFlow] Key does not exist");
-            });
-
-            it("should update $lastAction with delete action when delete is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                const $value = stateAsync(Promise.resolve(1));
-                $map.add("key1", $value);
-                $map.delete("key1");
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("delete");
-                if (action.type === "delete") {
-                    expect(action.key).toBe("key1");
-                    expect(action.removedValue).toBe($value);
-                }
-            });
-
-            it("should trigger reactivity when delete is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                const onData = vi.fn();
-                subscribe((t) => $map.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $map.delete("key1");
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-            });
-        });
-
-        describe("clear", () => {
-            it("should remove all entries from map", async () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                    key3: stateAsync(Promise.resolve(3)),
-                });
-                expect((await $map.pick()).size).toBe(3);
-
-                $map.clear();
-                expect((await $map.pick()).size).toBe(0);
-            });
-
-            it("should update $lastAction with clear action when clear is called", async () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                    key2: stateAsync(Promise.resolve(2)),
-                });
-                $map.clear();
-                const action = await $map.$lastAction.pick();
-                expect(action.type).toBe("clear");
-                if (action.type === "clear") {
-                    expect(action.clearedMap).toBeInstanceOf(Map);
-                    expect(action.clearedMap.size).toBe(2);
-                }
-            });
-        });
-
-        describe("$lastAction", () => {
-            describe("set action", () => {
-                it("should initialize $lastAction with set action on creation", async () => {
-                    const $value1 = stateAsync(Promise.resolve(1));
-                    const $value2 = stateAsync(Promise.resolve(2));
-                    const $map = map({
-                        key1: $value1,
-                        key2: $value2,
-                    });
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toEqual({
-                        type: "set",
-                        setMap: expect.any(Map),
-                        clearedMap: expect.any(Map),
-                    });
-                    if (action.type === "set") {
-                        expect(action.setMap.get("key1")).toBe($value1);
-                        expect(action.setMap.get("key2")).toBe($value2);
-                    }
-                });
-
-                it("should update $lastAction with set action when set is called", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                    });
-                    const $newValue = stateAsync(Promise.resolve(2));
-                    const newMap = new Map([["key2", $newValue]]);
-                    $map.set(newMap);
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toEqual({
-                        type: "set",
-                        setMap: newMap,
-                        clearedMap: expect.any(Map),
-                    });
-                });
-
-                it("should have correct structure for set action (type + setMap + clearedMap with FlowStateAsync)", async () => {
-                    const $value = stateAsync(Promise.resolve(1));
-                    const $map = map({ key1: $value });
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toHaveProperty("type", "set");
-                    if (action.type === "set") {
-                        expect(action).toHaveProperty("setMap");
-                        expect(action).toHaveProperty("clearedMap");
-                        expect(action.setMap).toBeInstanceOf(Map);
-                        expect(action.clearedMap).toBeInstanceOf(Map);
-                        expect(action.setMap.get("key1")).toBe($value);
-                    }
-                });
-            });
-
-            describe("add action", () => {
-                it("should update $lastAction with add action when add is called", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const $value = stateAsync(Promise.resolve(1));
-                    $map.add("key1", $value);
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toEqual({
-                        type: "add",
-                        key: "key1",
-                        addedValue: $value,
-                    });
-                });
-
-                it("should have correct structure for add action (type + key + FlowStateAsync addedValue)", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const $value = stateAsync(Promise.resolve(100));
-                    $map.add("key1", $value);
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toHaveProperty("type", "add");
-                    if (action.type === "add") {
-                        expect(action).toHaveProperty("key");
-                        expect(action).toHaveProperty("addedValue");
-                        expect(action.key).toBe("key1");
-                        expect(action.addedValue).toBe($value);
-                        expect(await action.addedValue.pick()).toBe(100);
-                    }
-                });
-            });
-
-            describe("update action", () => {
-                it("should update $lastAction with update action when update is called", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    $map.add("key1", stateAsync(Promise.resolve(1)));
-                    const $newValue = stateAsync(Promise.resolve(2));
-                    $map.update("key1", $newValue);
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toEqual({
-                        type: "update",
-                        key: "key1",
-                        setValue: $newValue,
-                        clearedValue: expect.any(Object),
-                    });
-                });
-
-                it("should have correct structure for update action (type + key + FlowStateAsync setValue + clearedValue)", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    $map.add("key1", stateAsync(Promise.resolve(1)));
-                    const $newValue = stateAsync(Promise.resolve(200));
-                    $map.update("key1", $newValue);
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toHaveProperty("type", "update");
-                    if (action.type === "update") {
-                        expect(action).toHaveProperty("key");
-                        expect(action).toHaveProperty("setValue");
-                        expect(action).toHaveProperty("clearedValue");
-                        expect(action.key).toBe("key1");
-                        expect(action.setValue).toBe($newValue);
-                        expect(await action.setValue.pick()).toBe(200);
-                    }
-                });
-            });
-
-            describe("delete action", () => {
-                it("should update $lastAction with delete action when delete is called", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const $value = stateAsync(Promise.resolve(1));
-                    $map.add("key1", $value);
-                    $map.delete("key1");
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toEqual({
-                        type: "delete",
-                        key: "key1",
-                        removedValue: $value,
-                    });
-                });
-
-                it("should have correct structure for delete action (type + key + FlowStateAsync removedValue)", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const $value = stateAsync(Promise.resolve(300));
-                    $map.add("key1", $value);
-                    $map.delete("key1");
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toHaveProperty("type", "delete");
-                    if (action.type === "delete") {
-                        expect(action).toHaveProperty("key");
-                        expect(action).toHaveProperty("removedValue");
-                        expect(action.key).toBe("key1");
-                        expect(action.removedValue).toBe($value);
-                    }
-                });
-            });
-
-            describe("clear action", () => {
-                it("should update $lastAction with clear action when clear is called", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                        key2: stateAsync(Promise.resolve(2)),
-                    });
-                    $map.clear();
-                    const action = await $map.$lastAction.pick();
-                    expect(action.type).toBe("clear");
-                    if (action.type === "clear") {
-                        expect(action.clearedMap).toBeInstanceOf(Map);
-                        expect(action.clearedMap.size).toBe(2);
-                    }
-                });
-
-                it("should have correct structure for clear action (type + clearedMap)", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                    });
-                    $map.clear();
-                    const action = await $map.$lastAction.pick();
-                    expect(action).toHaveProperty("type", "clear");
-                    if (action.type === "clear") {
-                        expect(action).toHaveProperty("clearedMap");
-                        expect(action.clearedMap).toBeInstanceOf(Map);
-                    }
-                });
-            });
-        });
-
-        describe("edge cases", () => {
-            it("should handle multiple rapid operations", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                $map.add("key2", stateAsync(Promise.resolve(2)));
-                $map.add("key3", stateAsync(Promise.resolve(3)));
-                $map.update("key1", stateAsync(Promise.resolve(10)));
-                $map.delete("key2");
-                $map.add("key4", stateAsync(Promise.resolve(4)));
-                $map.clear();
-                $map.add("key5", stateAsync(Promise.resolve(5)));
-
-                expect((await $map.pick()).size).toBe(1);
-                expect(await (await $map.pick()).get("key5")?.pick()).toBe(5);
-            });
-
-            it("should handle empty map operations", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                expect((await $map.pick()).size).toBe(0);
-
-                $map.add("key1", stateAsync(Promise.resolve(1)));
-                expect((await $map.pick()).size).toBe(1);
-
-                $map.delete("key1");
-                expect((await $map.pick()).size).toBe(0);
-            });
-
-            it("should handle map with single entry", async () => {
-                const $map = map<string, FlowStateAsync<number>>({
-                    key1: stateAsync(Promise.resolve(1)),
-                });
-                expect((await $map.pick()).size).toBe(1);
-
-                $map.update("key1", stateAsync(Promise.resolve(2)));
-                expect(await (await $map.pick()).get("key1")?.pick()).toBe(2);
-
-                $map.delete("key1");
-                expect((await $map.pick()).size).toBe(0);
-            });
-
-            it("should handle map with many entries", async () => {
-                const $map = map<string, FlowStateAsync<number>>();
-                for (let i = 0; i < 100; i++) {
-                    $map.add(`key${i}`, stateAsync(Promise.resolve(i)));
-                }
-                expect((await $map.pick()).size).toBe(100);
-
-                for (let i = 0; i < 50; i++) {
-                    $map.delete(`key${i}`);
-                }
-                expect((await $map.pick()).size).toBe(50);
-            });
-
-            it("should handle disposed values in map", async () => {
-                const $value = stateAsync(Promise.resolve(1));
-                const $map = map(new Map([["key1", $value]]));
-
-                $map.delete("key1");
-
-                // In flow2, values are NOT automatically disposed
-                expect($value.disposed).toBe(false);
-                expect((await $map.pick()).size).toBe(0);
-            });
-
-            it("should handle effects on FlowStateAsync values in map", async () => {
-                const $value = stateAsync(Promise.resolve(1));
-                const $map = map(new Map([["key1", $value]]));
-                const onData = vi.fn();
-
-                subscribe(
-                    (t) => $map.get(t).get("key1")?.get(t),
-                    (data) => {
-                        if (data) onData(data);
-                    },
-                );
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-
-                $value.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(2);
-            });
-        });
-    });
-
-    describe("integration", () => {
-        describe("with effects", () => {
-            describe("reactivity", () => {
-                it("should call effect when initialized", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                        key2: stateAsync(Promise.resolve(2)),
-                    });
-                    const onData = vi.fn();
-                    subscribe((t) => $map.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                    expect(onData).toHaveBeenLastCalledWith(
-                        expect.objectContaining({
-                            size: 2,
-                        }),
-                    );
-                });
-
-                it("should call effect when updated with set", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                    });
-                    const onData = vi.fn();
-                    subscribe((t) => $map.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    const $newValue = stateAsync(Promise.resolve(2));
-                    $map.set(new Map([["key2", $newValue]]));
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith(
-                        expect.objectContaining({
-                            size: 1,
-                        }),
-                    );
-                });
-
-                it("should call effect when updated with add", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const onData = vi.fn();
-                    subscribe((t) => $map.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                    expect(onData).toHaveBeenLastCalledWith(new Map());
-
-                    const $key1Value = stateAsync(Promise.resolve(1));
-                    $map.add("key1", $key1Value);
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith(new Map([["key1", $key1Value]]));
-
-                    const $key2Value = stateAsync(Promise.resolve(2));
-                    $map.add("key2", $key2Value);
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                    expect(onData).toHaveBeenLastCalledWith(
-                        new Map([
-                            ["key1", $key1Value],
-                            ["key2", $key2Value],
-                        ]),
-                    );
-                });
-
-                it("should call effect when updated with update", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    $map.add("key1", stateAsync(Promise.resolve(1)));
-                    const onData = vi.fn();
-                    subscribe((t) => $map.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    const $newValue = stateAsync(Promise.resolve(2));
-                    $map.update("key1", $newValue);
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith(new Map([["key1", $newValue]]));
-                });
-
-                it("should call effect when updated with delete", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    $map.add("key1", stateAsync(Promise.resolve(1)));
-                    $map.add("key2", stateAsync(Promise.resolve(2)));
-                    const onData = vi.fn();
-                    subscribe((t) => $map.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $map.delete("key1");
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    const mapAfterDelete = onData.mock.calls[1][0];
-                    expect(mapAfterDelete.size).toBe(1);
-                    expect(mapAfterDelete.has("key2")).toBe(true);
-                });
-
-                it("should call effect when updated with clear", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                        key2: stateAsync(Promise.resolve(2)),
-                    });
-                    const onData = vi.fn();
-                    subscribe((t) => $map.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $map.clear();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith(new Map());
-                });
-
-                it("should call effect when FlowStateAsync values in map are updated", async () => {
-                    const $value = stateAsync(Promise.resolve(1));
-                    const $map = map(new Map([["key1", $value]]));
-                    const onData = vi.fn();
-
-                    subscribe(
-                        (t) => $map.get(t).get("key1")?.get(t),
-                        (data) => {
-                            if (data) onData(data);
-                        },
-                    );
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                    expect(onData).toHaveBeenLastCalledWith(1);
-
-                    $value.set(Promise.resolve(2));
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                    expect(onData).toHaveBeenLastCalledWith(2);
-                });
-            });
-
-            describe("$lastAction", () => {
-                it("should call effect when $lastAction is updated with set action", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                    });
-                    const onData = vi.fn();
-                    subscribe((t) => $map.$lastAction.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    const $newValue = stateAsync(Promise.resolve(2));
-                    $map.set(new Map([["key2", $newValue]]));
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith({
-                        type: "set",
-                        setMap: expect.any(Map),
-                        clearedMap: expect.any(Map),
-                    });
-                });
-
-                it("should call effect when $lastAction is updated with add action", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const onData = vi.fn();
-                    subscribe((t) => $map.$lastAction.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    const $value = stateAsync(Promise.resolve(1));
-                    $map.add("key1", $value);
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith({
-                        type: "add",
-                        key: "key1",
-                        addedValue: $value,
-                    });
-                });
-
-                it("should call effect when $lastAction is updated with update action", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    $map.add("key1", stateAsync(Promise.resolve(1)));
-                    const onData = vi.fn();
-                    subscribe((t) => $map.$lastAction.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    const $newValue = stateAsync(Promise.resolve(2));
-                    $map.update("key1", $newValue);
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith({
-                        type: "update",
-                        key: "key1",
-                        setValue: $newValue,
-                        clearedValue: expect.any(Object),
-                    });
-                });
-
-                it("should call effect when $lastAction is updated with delete action", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const $value = stateAsync(Promise.resolve(1));
-                    $map.add("key1", $value);
-                    const onData = vi.fn();
-                    subscribe((t) => $map.$lastAction.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $map.delete("key1");
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith({
-                        type: "delete",
-                        key: "key1",
-                        removedValue: $value,
-                    });
-                });
-
-                it("should call effect when $lastAction is updated with clear action", async () => {
-                    const $map = map<string, FlowStateAsync<number>>({
-                        key1: stateAsync(Promise.resolve(1)),
-                        key2: stateAsync(Promise.resolve(2)),
-                    });
-                    const onData = vi.fn();
-                    subscribe((t) => $map.$lastAction.get(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $map.clear();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                    expect(onData).toHaveBeenLastCalledWith({
-                        type: "clear",
-                        clearedMap: expect.any(Map),
-                    });
-                });
-
-                it("should call effect when FlowStateAsync value in $lastAction is updated", async () => {
-                    const $map = map<string, FlowStateAsync<number>>();
-                    const $value = stateAsync(Promise.resolve(1));
-                    $map.add("key1", $value);
-                    const onData = vi.fn();
-
-                    subscribe((t) => {
-                        const action = $map.$lastAction.get(t);
-                        if (action.type === "add") {
-                            return action.addedValue.get(t);
-                        }
-                        return undefined;
-                    }, onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                    expect(onData).toHaveBeenLastCalledWith(1);
-
-                    $value.set(Promise.resolve(2));
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                    expect(onData).toHaveBeenLastCalledWith(2);
-                });
-            });
-        });
-    });
-});