@ersbeth/picoflow 1.0.1 → 1.1.1

package/test/collections/flowMap.scalars.test.ts

@@ -0,0 +1,877 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { effect, FlowGraph, map, state } from "#package";
+
+describe("FlowMap", () => {
+	describe("unit", () => {
+		describe("initialization", () => {
+			it("should initialize with provided Record values", async () => {
+				const $map = map({
+					key1: 1,
+					key2: 2,
+					key3: 3,
+				});
+
+				expect(Array.from((await $map.pick()).entries())).toEqual([
+					["key1", 1],
+					["key2", 2],
+					["key3", 3],
+				]);
+			});
+
+			it("should initialize with provided Map", async () => {
+				const initialMap = new Map([
+					["key1", 1],
+					["key2", 2],
+				]);
+				const $map = map(initialMap);
+
+				expect(Array.from((await $map.pick()).entries())).toEqual([
+					["key1", 1],
+					["key2", 2],
+				]);
+			});
+
+			it("should initialize with empty map when no value provided", async () => {
+				const $map = map<string, 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 $map = map({ key1: 1, key2: 2 });
+				const action = await $map.$lastAction.pick();
+				expect(action.type).toBe("set");
+				if (action.type === "set") {
+					expect(Array.from(action.map.entries())).toEqual([
+						["key1", 1],
+						["key2", 2],
+					]);
+				}
+			});
+
+			it("should initialize $lastAction with empty map when no value provided", async () => {
+				const $map = map<string, number>();
+				const action = await $map.$lastAction.pick();
+				expect(action.type).toBe("set");
+				if (action.type === "set") {
+					expect(action.map.size).toBe(0);
+				}
+			});
+		});
+
+		describe("disposal", () => {
+			it("should have disposed property set to false initially and true after disposal", () => {
+				const $map = map({ key1: 1, key2: 2 });
+				expect($map.disposed).toBe(false);
+				$map.dispose();
+				expect($map.disposed).toBe(true);
+			});
+
+			it("should throw error when disposed twice", () => {
+				const $map = map({ key1: 1, key2: 2 });
+				$map.dispose();
+				expect(() => $map.dispose()).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should throw when pick is called after disposal", async () => {
+				const $map = map({ key1: 1, key2: 2, key3: 3 });
+				$map.dispose();
+				await expect($map.pick()).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should throw when set is called after disposal", async () => {
+				const $map = map<string, number>({ key1: 1 });
+				$map.dispose();
+				await expect($map.set(new Map([["key2", 2]]))).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should throw when add is called after disposal", async () => {
+				const $map = map<string, number>();
+				$map.dispose();
+				await expect($map.add("key1", 2)).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should throw when update is called after disposal", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.dispose();
+				await expect($map.update("key1", 2)).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should throw when delete is called after disposal", async () => {
+				const $map = map<string, number>({ key1: 1, key2: 2, key3: 3 });
+				$map.dispose();
+				await expect($map.delete("key1")).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should throw when clear is called after disposal", async () => {
+				const $map = map<string, number>({ key1: 1, key2: 2 });
+				$map.dispose();
+				await expect($map.clear()).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should dispose values when FlowMap is disposed", () => {
+				const $value1 = state(1);
+				const $value2 = state(2);
+				const $value3 = state(3);
+				const $map = map(
+					new Map([
+						["key1", $value1],
+						["key2", $value2],
+						["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", () => {
+				const $value1 = state(1);
+				const $value2 = state(2);
+				const $map = map(
+					new Map([
+						["key1", $value1],
+						["key2", $value2],
+					]),
+				);
+
+				const $effect = effect((t) => {
+					$value1.get(t);
+				});
+
+				expect($effect.disposed).toBe(false);
+
+				$map.dispose({ self: true });
+
+				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, number>();
+				$map.add("key1", 1);
+				$map.add("key2", 2);
+				$map.add("key3", 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, number>({ key1: 1, key2: 2 });
+				const newMap = new Map<string, number>([
+					["key3", 3],
+					["key4", 4],
+				]);
+
+				await $map.set(newMap);
+				expect(Array.from((await $map.pick()).entries())).toEqual([
+					["key3", 3],
+					["key4", 4],
+				]);
+			});
+
+			it("should dispose values when set replaces map", async () => {
+				const $oldValue1 = state(1);
+				const $oldValue2 = state(2);
+				const $map = map(
+					new Map([
+						["key1", $oldValue1],
+						["key2", $oldValue2],
+					]),
+				);
+
+				expect($oldValue1.disposed).toBe(false);
+				expect($oldValue2.disposed).toBe(false);
+
+				await $map.set(
+					new Map([
+						["key3", state(3)],
+						["key4", state(4)],
+					]),
+				);
+
+				expect($oldValue1.disposed).toBe(true);
+				expect($oldValue2.disposed).toBe(true);
+			});
+
+			it("should dispose values with self option when set replaces map", async () => {
+				const $oldValue = state(1);
+				const $map = map(new Map([["key1", $oldValue]]));
+
+				const $effect = effect((t) => {
+					$oldValue.get(t);
+				});
+
+				expect($effect.disposed).toBe(false);
+
+				await $map.set(new Map([["key2", state(2)]]));
+
+				expect($oldValue.disposed).toBe(true);
+				expect($effect.disposed).toBe(false);
+
+				$effect.dispose();
+			});
+
+			it("should update $lastAction with set action when set is called", async () => {
+				const $map = map<string, number>({ key1: 1, key2: 2 });
+				const newMap = new Map<string, number>([
+					["key3", 3],
+					["key4", 4],
+				]);
+
+				await $map.set(newMap);
+				const action = await $map.$lastAction.pick();
+				expect(action).toEqual({
+					type: "set",
+					map: newMap,
+				});
+			});
+		});
+
+		describe("add", () => {
+			it("should add key-value pair to map", async () => {
+				const $map = map<string, number>();
+
+				$map.add("key1", 1);
+				expect((await $map.pick()).get("key1")).toBe(1);
+				expect((await $map.pick()).size).toBe(1);
+			});
+
+			it("should add multiple keys successively", async () => {
+				const $map = map<string, number>();
+
+				$map.add("key1", 1);
+				$map.add("key2", 2);
+				$map.add("key3", 3);
+
+				expect((await $map.pick()).size).toBe(3);
+				expect((await $map.pick()).get("key1")).toBe(1);
+				expect((await $map.pick()).get("key2")).toBe(2);
+				expect((await $map.pick()).get("key3")).toBe(3);
+			});
+
+			it("should throw when key already exists", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				await expect($map.add("key1", 2)).rejects.toThrow(
+					"[PicoFlow] Key already exists",
+				);
+			});
+
+			it("should update $lastAction with add action when add is called", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				const action = await $map.$lastAction.pick();
+				expect(action).toEqual({
+					type: "add",
+					key: "key1",
+					value: 1,
+				});
+			});
+
+			it("should trigger reactivity when add is called", async () => {
+				const $map = map<string, number>();
+				const effectFn = vi.fn();
+				effect((t) => effectFn($map.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				$map.add("key1", 1);
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+			});
+		});
+
+		describe("update", () => {
+			it("should update existing key-value pair", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+
+				$map.update("key1", 2);
+				expect((await $map.pick()).get("key1")).toBe(2);
+			});
+
+			it("should update multiple keys successively", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.add("key2", 2);
+
+				$map.update("key1", 10);
+				$map.update("key2", 20);
+
+				expect((await $map.pick()).get("key1")).toBe(10);
+				expect((await $map.pick()).get("key2")).toBe(20);
+			});
+
+			it("should throw when key does not exist", async () => {
+				const $map = map<string, number>();
+				await expect($map.update("key1", 1)).rejects.toThrow(
+					"[PicoFlow] Key does not exist",
+				);
+			});
+
+			it("should update $lastAction with update action when update is called", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.update("key1", 2);
+				const action = await $map.$lastAction.pick();
+				expect(action).toEqual({
+					type: "update",
+					key: "key1",
+					value: 2,
+				});
+			});
+
+			it("should trigger reactivity when update is called", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				const effectFn = vi.fn();
+				effect((t) => effectFn($map.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				$map.update("key1", 2);
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+			});
+		});
+
+		describe("delete", () => {
+			it("should delete key from map", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.add("key2", 2);
+
+				$map.delete("key1");
+				expect((await $map.pick()).get("key1")).toBe(undefined);
+				expect((await $map.pick()).get("key2")).toBe(2);
+				expect((await $map.pick()).size).toBe(1);
+			});
+
+			it("should delete multiple keys successively", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.add("key2", 2);
+				$map.add("key3", 3);
+
+				$map.delete("key1");
+				$map.delete("key2");
+
+				expect((await $map.pick()).size).toBe(1);
+				expect((await $map.pick()).get("key3")).toBe(3);
+			});
+
+			it("should throw when key does not exist", async () => {
+				const $map = map<string, number>();
+				await expect($map.delete("key1")).rejects.toThrow(
+					"[PicoFlow] Key does not exist",
+				);
+			});
+
+			it("should update $lastAction with delete action when delete is called", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.delete("key1");
+				const action = await $map.$lastAction.pick();
+				expect(action).toEqual({
+					type: "delete",
+					key: "key1",
+					value: 1,
+				});
+			});
+
+			it("should trigger reactivity when delete is called", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				const effectFn = vi.fn();
+				effect((t) => effectFn($map.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				$map.delete("key1");
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+			});
+
+			it("should dispose value when delete is called", () => {
+				const $value = state(1);
+				const $map = map(new Map([["key1", $value]]));
+
+				expect($value.disposed).toBe(false);
+
+				$map.delete("key1");
+
+				expect($value.disposed).toBe(true);
+			});
+		});
+
+		describe("clear", () => {
+			it("should remove all entries from map", async () => {
+				const $map = map({ key1: 1, key2: 2, key3: 3 });
+				expect((await $map.pick()).size).toBe(3);
+
+				$map.clear();
+				expect((await $map.pick()).size).toBe(0);
+			});
+
+			it("should dispose all values when clear is called", () => {
+				const $value1 = state(1);
+				const $value2 = state(2);
+				const $value3 = state(3);
+				const $map = map(
+					new Map([
+						["key1", $value1],
+						["key2", $value2],
+						["key3", $value3],
+					]),
+				);
+
+				expect($value1.disposed).toBe(false);
+				expect($value2.disposed).toBe(false);
+				expect($value3.disposed).toBe(false);
+
+				$map.clear();
+
+				expect($value1.disposed).toBe(true);
+				expect($value2.disposed).toBe(true);
+				expect($value3.disposed).toBe(true);
+			});
+
+			it("should dispose values with self option when clear is called", async () => {
+				const $value = state(1);
+				const $value2 = state(2);
+				const $map = map(
+					new Map([
+						["key1", $value],
+						["key2", $value2],
+					]),
+				);
+
+				const $effect = effect((t) => {
+					$value.get(t);
+				});
+
+				expect($effect.disposed).toBe(false);
+
+				await $map.clear();
+
+				expect($value.disposed).toBe(true);
+				expect($effect.disposed).toBe(false);
+
+				$effect.dispose();
+			});
+
+			it("should update $lastAction with clear action when clear is called", async () => {
+				const $map = map({ key1: 1, key2: 2 });
+				$map.clear();
+				const action = await $map.$lastAction.pick();
+				expect(action).toEqual({ type: "clear" });
+			});
+		});
+
+		describe("$lastAction", () => {
+			describe("set action", () => {
+				it("should initialize $lastAction with set action on creation", async () => {
+					const $map = map({ key1: 1, key2: 2 });
+					const action = await $map.$lastAction.pick();
+					expect(action).toEqual({
+						type: "set",
+						map: expect.any(Map),
+					});
+					if (action.type === "set") {
+						expect(Array.from(action.map.entries())).toEqual([
+							["key1", 1],
+							["key2", 2],
+						]);
+					}
+				});
+
+				it("should update $lastAction with set action when set is called", async () => {
+					const $map = map<string, number>({ key1: 1 });
+					const newMap = new Map<string, number>([["key2", 2]]);
+					await $map.set(newMap);
+					const action = await $map.$lastAction.pick();
+					expect(action).toEqual({
+						type: "set",
+						map: newMap,
+					});
+				});
+
+				it("should have correct structure for set action (type + map)", async () => {
+					const $map = map({ key1: 1 });
+					const action = await $map.$lastAction.pick();
+					expect(action).toHaveProperty("type", "set");
+					if (action.type === "set") {
+						expect(action).toHaveProperty("map");
+						expect(action.map).toBeInstanceOf(Map);
+					}
+				});
+			});
+
+			describe("add action", () => {
+				it("should update $lastAction with add action when add is called", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					const action = await $map.$lastAction.pick();
+					expect(action).toEqual({
+						type: "add",
+						key: "key1",
+						value: 1,
+					});
+				});
+
+				it("should have correct structure for add action (type + key + value)", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 100);
+					const action = await $map.$lastAction.pick();
+					expect(action).toHaveProperty("type", "add");
+					if (action.type === "add") {
+						expect(action).toHaveProperty("key");
+						expect(action).toHaveProperty("value");
+						expect(action.key).toBe("key1");
+						expect(action.value).toBe(100);
+					}
+				});
+			});
+
+			describe("update action", () => {
+				it("should update $lastAction with update action when update is called", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					$map.update("key1", 2);
+					const action = await $map.$lastAction.pick();
+					expect(action).toEqual({
+						type: "update",
+						key: "key1",
+						value: 2,
+					});
+				});
+
+				it("should have correct structure for update action (type + key + value)", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					$map.update("key1", 200);
+					const action = await $map.$lastAction.pick();
+					expect(action).toHaveProperty("type", "update");
+					if (action.type === "update") {
+						expect(action).toHaveProperty("key");
+						expect(action).toHaveProperty("value");
+						expect(action.key).toBe("key1");
+						expect(action.value).toBe(200);
+					}
+				});
+			});
+
+			describe("delete action", () => {
+				it("should update $lastAction with delete action when delete is called", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					$map.delete("key1");
+					const action = await $map.$lastAction.pick();
+					expect(action).toEqual({
+						type: "delete",
+						key: "key1",
+						value: 1,
+					});
+				});
+
+				it("should have correct structure for delete action (type + key + value)", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 300);
+					$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("value");
+						expect(action.key).toBe("key1");
+						expect(action.value).toBe(300);
+					}
+				});
+			});
+
+			describe("clear action", () => {
+				it("should update $lastAction with clear action when clear is called", async () => {
+					const $map = map({ key1: 1, key2: 2 });
+					$map.clear();
+					const action = await $map.$lastAction.pick();
+					expect(action).toEqual({
+						type: "clear",
+					});
+				});
+
+				it("should have correct structure for clear action (type only)", async () => {
+					const $map = map({ key1: 1 });
+					$map.clear();
+					const action = await $map.$lastAction.pick();
+					expect(action).toHaveProperty("type", "clear");
+					if (action.type === "clear") {
+						expect(action).not.toHaveProperty("key");
+						expect(action).not.toHaveProperty("value");
+						expect(action).not.toHaveProperty("map");
+					}
+				});
+			});
+		});
+
+		describe("edge cases", () => {
+			it("should handle multiple rapid operations", async () => {
+				const $map = map<string, number>();
+				$map.add("key1", 1);
+				$map.add("key2", 2);
+				$map.add("key3", 3);
+				$map.update("key1", 10);
+				$map.delete("key2");
+				$map.add("key4", 4);
+				$map.clear();
+				$map.add("key5", 5);
+
+				expect((await $map.pick()).size).toBe(1);
+				expect((await $map.pick()).get("key5")).toBe(5);
+			});
+
+			it("should handle empty map operations", async () => {
+				const $map = map<string, number>();
+				expect((await $map.pick()).size).toBe(0);
+
+				$map.add("key1", 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({ key1: 1 });
+				expect((await $map.pick()).size).toBe(1);
+
+				$map.update("key1", 2);
+				expect((await $map.pick()).get("key1")).toBe(2);
+
+				$map.delete("key1");
+				expect((await $map.pick()).size).toBe(0);
+			});
+
+			it("should handle map with many entries", async () => {
+				const $map = map<string, number>();
+				for (let i = 0; i < 100; i++) {
+					$map.add(`key${i}`, 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);
+			});
+		});
+	});
+
+	describe("integration", () => {
+		beforeEach(() => {
+			FlowGraph.clear();
+		});
+
+		describe("with effects", () => {
+			describe("reactivity", () => {
+				it("should call effect when initialized", async () => {
+					const $map = map({ key1: 1, key2: 2 });
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+					expect(effectFn).toHaveBeenLastCalledWith(
+						expect.objectContaining({
+							size: 2,
+						}),
+					);
+				});
+
+				it("should call effect when updated with set", async () => {
+					const $map = map<string, number>({ key1: 1 });
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					await $map.set(new Map([["key2", 2]]));
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith(
+						expect.objectContaining({
+							size: 1,
+						}),
+					);
+				});
+
+				it("should call effect when updated with add", async () => {
+					const $map = map<string, number>();
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+					expect(effectFn).toHaveBeenLastCalledWith(new Map());
+
+					$map.add("key1", 1);
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith(new Map([["key1", 1]]));
+
+					$map.add("key2", 2);
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+					expect(effectFn).toHaveBeenLastCalledWith(
+						new Map([
+							["key1", 1],
+							["key2", 2],
+						]),
+					);
+				});
+
+				it("should call effect when updated with update", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.update("key1", 2);
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith(new Map([["key1", 2]]));
+				});
+
+				it("should call effect when updated with delete", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					$map.add("key2", 2);
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.delete("key1");
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith(new Map([["key2", 2]]));
+				});
+
+				it("should call effect when updated with clear", async () => {
+					const $map = map({ key1: 1, key2: 2 });
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.clear();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith(new Map());
+				});
+			});
+
+			describe("$lastAction", () => {
+				it("should call effect when $lastAction is updated with set action", async () => {
+					const $map = map<string, number>({ key1: 1 });
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.$lastAction.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					await $map.set(new Map([["key2", 2]]));
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith({
+						type: "set",
+						map: expect.any(Map),
+					});
+				});
+
+				it("should call effect when $lastAction is updated with add action", async () => {
+					const $map = map<string, number>();
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.$lastAction.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.add("key1", 1);
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith({
+						type: "add",
+						key: "key1",
+						value: 1,
+					});
+				});
+
+				it("should call effect when $lastAction is updated with update action", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.$lastAction.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.update("key1", 2);
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith({
+						type: "update",
+						key: "key1",
+						value: 2,
+					});
+				});
+
+				it("should call effect when $lastAction is updated with delete action", async () => {
+					const $map = map<string, number>();
+					$map.add("key1", 1);
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.$lastAction.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.delete("key1");
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith({
+						type: "delete",
+						key: "key1",
+						value: 1,
+					});
+				});
+
+				it("should call effect when $lastAction is updated with clear action", async () => {
+					const $map = map({ key1: 1, key2: 2 });
+					const effectFn = vi.fn();
+					effect((t) => effectFn($map.$lastAction.get(t)));
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$map.clear();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+					expect(effectFn).toHaveBeenLastCalledWith({ type: "clear" });
+				});
+			});
+		});
+	});
+});