@ersbeth/picoflow 0.2.3 → 1.0.0

package/test/effect.test.ts

@@ -2,28 +2,28 @@ import { describe, expect, test, vi } from "vitest";
 import { effect, signal } from "#package";
 
 describe("effect", () => {
-    test("disposed is correct", () => {
-        const $signal = signal();
-        const effectFn = vi.fn();
-        const $effect = effect((_, watch) => {
-            watch($signal);
-            effectFn();
-        });
+	test("disposed is correct", () => {
+		const $signal = signal();
+		const effectFn = vi.fn();
+		const $effect = effect((t) => {
+			$signal.watch(t);
+			effectFn();
+		});
 
-        expect($effect.disposed).toBe(false);
-        $effect.dispose();
-        expect($effect.disposed).toBe(true);
-    });
+		expect($effect.disposed).toBe(false);
+		$effect.dispose();
+		expect($effect.disposed).toBe(true);
+	});
 
-    test("throw when disposed twice", () => {
-        const $signal = signal();
-        const effectFn = vi.fn();
-        const $effect = effect((_, watch) => {
-            watch($signal);
-            effectFn();
-        });
+	test("throw when disposed twice", () => {
+		const $signal = signal();
+		const effectFn = vi.fn();
+		const $effect = effect((t) => {
+			$signal.watch(t);
+			effectFn();
+		});
 
-        $effect.dispose();
-        expect(() => $effect.dispose()).toThrow("Effect is disposed");
-    });
+		$effect.dispose();
+		expect(() => $effect.dispose()).toThrow("Effect is disposed");
+	});
 });

package/test/map.test.ts

@@ -1,144 +1,240 @@
 import { describe, expect, test, vi } from "vitest";
-import { effect, map } from "#package";
+import { effect, type FlowState, map, state } from "#package";
 
 describe("map", () => {
-    test("is initialized", () => {
-        const $map = map({
-            key1: 1,
-            key2: 2,
-            key3: 3,
-        });
-
-        expect(Array.from($map.get().entries())).toEqual([
-            ["key1", 1],
-            ["key2", 2],
-            ["key3", 3],
-        ]);
-    });
-
-    test("is updated", () => {
-        const $map = map();
-
-        expect(Array.from($map.get().entries())).toEqual([]);
-
-        $map.setAt("key1", 1);
-        expect($map.get().get("key1")).toBe(1);
-        expect($map.$lastSet.get()).toEqual({ key: "key1", value: 1 });
-
-        $map.setAt("key2", 2);
-        expect($map.get().get("key1")).toBe(1);
-        expect($map.get().get("key2")).toBe(2);
-        expect($map.$lastSet.get()).toEqual({ key: "key2", value: 2 });
-
-        $map.setAt("key1", 3);
-        expect($map.get().get("key1")).toBe(3);
-        expect($map.get().get("key2")).toBe(2);
-        expect($map.$lastSet.get()).toEqual({ key: "key1", value: 3 });
-
-        $map.delete("key1");
-        expect($map.get().get("key1")).toBe(undefined);
-        expect($map.get().get("key2")).toBe(2);
-        expect($map.$lastDeleted.get()).toEqual({ key: "key1", value: 3 });
-    });
-
-    test("get throws when disposed", () => {
-        const $map = map({ key1: 1, key2: 2, key3: 3 });
-        $map.dispose();
-        expect(() => $map.get()).toThrowError(
-            "[PicoFlow] Primitive is disposed",
-        );
-    });
-
-    test("set throws when disposed", () => {
-        const $map = map<string, number>();
-        $map.dispose();
-        expect(() => $map.setAt("key1", 2)).toThrowError(
-            "[PicoFlow] Primitive is disposed",
-        );
-    });
-
-    test("delete throws when disposed", () => {
-        const $map = map<string, number>({ key1: 1, key2: 2, key3: 3 });
-        $map.dispose();
-        expect(() => $map.delete("key1")).toThrowError(
-            "[PicoFlow] Primitive is disposed",
-        );
-    });
+	test("is initialized", () => {
+		const $map = map({
+			key1: 1,
+			key2: 2,
+			key3: 3,
+		});
+
+		expect(Array.from($map.pick().entries())).toEqual([
+			["key1", 1],
+			["key2", 2],
+			["key3", 3],
+		]);
+	});
+
+	test("is updated", () => {
+		const $map = map();
+
+		expect(Array.from($map.pick().entries())).toEqual([]);
+
+		$map.add("key1", 1);
+		expect($map.pick().get("key1")).toBe(1);
+		expect($map.$lastAdded.pick()).toEqual({ key: "key1", value: 1 });
+
+		$map.add("key2", 2);
+		expect($map.pick().get("key1")).toBe(1);
+		expect($map.pick().get("key2")).toBe(2);
+		expect($map.$lastAdded.pick()).toEqual({ key: "key2", value: 2 });
+
+		$map.update("key1", 3);
+		expect($map.pick().get("key1")).toBe(3);
+		expect($map.pick().get("key2")).toBe(2);
+		expect($map.$lastUpdated.pick()).toEqual({ key: "key1", value: 3 });
+
+		$map.delete("key1");
+		expect($map.pick().get("key1")).toBe(undefined);
+		expect($map.pick().get("key2")).toBe(2);
+		expect($map.$lastDeleted.pick()).toEqual({ key: "key1", value: 3 });
+	});
+
+	test("get throws when disposed", () => {
+		const $map = map({ key1: 1, key2: 2, key3: 3 });
+		$map.dispose();
+		expect(() => $map.pick()).toThrowError("[PicoFlow] Primitive is disposed");
+	});
+
+	test("add throws when disposed", () => {
+		const $map = map<string, number>();
+		$map.dispose();
+		expect(() => $map.add("key1", 2)).toThrowError(
+			"[PicoFlow] Primitive is disposed",
+		);
+	});
+
+	test("update throws when disposed", () => {
+		const $map = map<string, number>();
+		$map.add("key1", 1);
+		$map.dispose();
+		expect(() => $map.update("key1", 2)).toThrowError(
+			"[PicoFlow] Primitive is disposed",
+		);
+	});
+
+	test("delete throws when disposed", () => {
+		const $map = map<string, number>({ key1: 1, key2: 2, key3: 3 });
+		$map.dispose();
+		expect(() => $map.delete("key1")).toThrowError(
+			"[PicoFlow] Primitive is disposed",
+		);
+	});
+
+	test("add throws when key already exists", () => {
+		const $map = map<string, number>();
+		$map.add("key1", 1);
+		expect(() => $map.add("key1", 2)).toThrowError(
+			"[PicoFlow] Key already exists",
+		);
+	});
+
+	test("update throws when key does not exist", () => {
+		const $map = map<string, number>();
+		expect(() => $map.update("key1", 1)).toThrowError(
+			"[PicoFlow] Key does not exist",
+		);
+	});
+
+	test("dispose disposes map values that are disposable", () => {
+		const $map = map<string, FlowState<number>>();
+		const $value1 = state(1);
+		const $value2 = state(2);
+		const $value3 = state(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);
+	});
+
+	test("dispose clears the map after disposing values", () => {
+		const $map = map<string, FlowState<number>>();
+		const $value1 = state(1);
+		const $value2 = state(2);
+
+		$map.add("key1", $value1);
+		$map.add("key2", $value2);
+
+		expect($map.pick().size).toBe(2);
+
+		$map.dispose();
+
+		// Map is cleared during disposal, but we can't verify after disposal
+		// since pick() will throw. We verify the values were disposed instead.
+		expect($value1.disposed).toBe(true);
+		expect($value2.disposed).toBe(true);
+	});
+
+	test("dispose handles non-disposable values gracefully", () => {
+		const $map = map<string, number>();
+		$map.add("key1", 1);
+		$map.add("key2", 2);
+		$map.add("key3", 3);
+
+		expect($map.pick().size).toBe(3);
+
+		// Should not throw even with non-disposable values
+		expect(() => $map.dispose()).not.toThrow();
+	});
+
+	test("dispose passes options to value disposal", () => {
+		const $map = map<string, FlowState<number>>();
+		const $value1 = state(1);
+		const $value2 = state(2);
+
+		$map.add("key1", $value1);
+		$map.add("key2", $value2);
+
+		// Create an effect that depends on value1
+		const fx = effect((t) => {
+			$value1.get(t);
+		});
+
+		expect(fx.disposed).toBe(false);
+
+		// Dispose with self: true - should only dispose the map and values, not dependent effects
+		$map.dispose({ self: true });
+
+		expect($value1.disposed).toBe(true);
+		expect($value2.disposed).toBe(true);
+		// Effect should still be active since we used self: true
+		expect(fx.disposed).toBe(false);
+
+		fx.dispose();
+	});
 });
 
 describe("effect", () => {
-    test("called when map is updated", () => {
-        const $map = map();
-        const onSetFn = vi.fn();
-        const onSetAtFn = vi.fn();
-        const onDeleteFn = vi.fn();
-
-        effect((get) => onSetFn(get($map)));
-        effect((get) => onSetAtFn(get($map.$lastSet)));
-        effect((get) => onDeleteFn(get($map.$lastDeleted)));
-
-        expect(onSetFn).toHaveBeenCalledTimes(1);
-        expect(onSetFn).toHaveBeenLastCalledWith(new Map());
-        expect(onSetAtFn).toHaveBeenCalledTimes(1);
-        expect(onSetAtFn).toHaveBeenLastCalledWith({
-            key: undefined,
-            value: undefined,
-        });
-        expect(onDeleteFn).toHaveBeenCalledTimes(1);
-        expect(onDeleteFn).toHaveBeenLastCalledWith({
-            key: undefined,
-            value: undefined,
-        });
-
-        $map.setAt("key1", 1);
-        expect(onSetFn).toHaveBeenCalledTimes(2);
-        expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key1", 1]]));
-        expect(onSetAtFn).toHaveBeenCalledTimes(2);
-        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key1", value: 1 });
-        expect(onDeleteFn).toHaveBeenCalledTimes(1);
-        expect(onDeleteFn).toHaveBeenLastCalledWith({
-            key: undefined,
-            value: undefined,
-        });
-
-        $map.setAt("key2", 2);
-        expect(onSetFn).toHaveBeenCalledTimes(3);
-        expect(onSetFn).toHaveBeenLastCalledWith(
-            new Map([
-                ["key1", 1],
-                ["key2", 2],
-            ]),
-        );
-        expect(onSetAtFn).toHaveBeenCalledTimes(3);
-        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
-        expect(onDeleteFn).toHaveBeenCalledTimes(1);
-        expect(onDeleteFn).toHaveBeenLastCalledWith({
-            key: undefined,
-            value: undefined,
-        });
-
-        $map.setAt("key1", 3);
-        expect(onSetFn).toHaveBeenCalledTimes(4);
-        expect(onSetFn).toHaveBeenLastCalledWith(
-            new Map([
-                ["key1", 3],
-                ["key2", 2],
-            ]),
-        );
-        expect(onSetAtFn).toHaveBeenCalledTimes(4);
-        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
-        expect(onDeleteFn).toHaveBeenCalledTimes(1);
-        expect(onDeleteFn).toHaveBeenLastCalledWith({
-            key: undefined,
-            value: undefined,
-        });
-
-        $map.delete("key1");
-        expect(onSetFn).toHaveBeenCalledTimes(5);
-        expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key2", 2]]));
-        expect(onSetAtFn).toHaveBeenCalledTimes(4);
-        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
-        expect(onDeleteFn).toHaveBeenCalledTimes(2);
-        expect(onDeleteFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
-    });
+	test("called when map is updated", () => {
+		const $map = map();
+		const onSetFn = vi.fn();
+		const onAddFn = vi.fn();
+		const onUpdateFn = vi.fn();
+		const onDeleteFn = vi.fn();
+
+		effect((t) => onSetFn($map.get(t)));
+		effect((t) => onAddFn($map.$lastAdded.get(t)));
+		effect((t) => onUpdateFn($map.$lastUpdated.get(t)));
+		effect((t) => onDeleteFn($map.$lastDeleted.get(t)));
+
+		expect(onSetFn).toHaveBeenCalledTimes(1);
+		expect(onSetFn).toHaveBeenLastCalledWith(new Map());
+		expect(onAddFn).toHaveBeenCalledTimes(1);
+		expect(onAddFn).toHaveBeenLastCalledWith(null);
+		expect(onUpdateFn).toHaveBeenCalledTimes(1);
+		expect(onUpdateFn).toHaveBeenLastCalledWith(null);
+		expect(onDeleteFn).toHaveBeenCalledTimes(1);
+		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
+
+		$map.add("key1", 1);
+		expect(onSetFn).toHaveBeenCalledTimes(2);
+		expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key1", 1]]));
+		expect(onAddFn).toHaveBeenCalledTimes(2);
+		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key1", value: 1 });
+		expect(onUpdateFn).toHaveBeenCalledTimes(1);
+		expect(onUpdateFn).toHaveBeenLastCalledWith(null);
+		expect(onDeleteFn).toHaveBeenCalledTimes(1);
+		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
+
+		$map.add("key2", 2);
+		expect(onSetFn).toHaveBeenCalledTimes(3);
+		expect(onSetFn).toHaveBeenLastCalledWith(
+			new Map([
+				["key1", 1],
+				["key2", 2],
+			]),
+		);
+		expect(onAddFn).toHaveBeenCalledTimes(3);
+		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
+		expect(onUpdateFn).toHaveBeenCalledTimes(1);
+		expect(onUpdateFn).toHaveBeenLastCalledWith(null);
+		expect(onDeleteFn).toHaveBeenCalledTimes(1);
+		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
+
+		$map.update("key1", 3);
+		expect(onSetFn).toHaveBeenCalledTimes(4);
+		expect(onSetFn).toHaveBeenLastCalledWith(
+			new Map([
+				["key1", 3],
+				["key2", 2],
+			]),
+		);
+		expect(onAddFn).toHaveBeenCalledTimes(3);
+		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
+		expect(onUpdateFn).toHaveBeenCalledTimes(2);
+		expect(onUpdateFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
+		expect(onDeleteFn).toHaveBeenCalledTimes(1);
+		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
+
+		$map.delete("key1");
+		expect(onSetFn).toHaveBeenCalledTimes(5);
+		expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key2", 2]]));
+		expect(onAddFn).toHaveBeenCalledTimes(3);
+		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
+		expect(onUpdateFn).toHaveBeenCalledTimes(2);
+		expect(onUpdateFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
+		expect(onDeleteFn).toHaveBeenCalledTimes(2);
+		expect(onDeleteFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
+	});
 });