@ersbeth/picoflow 0.2.3 → 1.0.0

package/test/derivation.test.ts

@@ -2,543 +2,538 @@ import { describe, expect, test, vi } from "vitest";
 import { derivation, effect, resource, signal, state } from "#package";
 
 describe("derivation", () => {
-    describe("from state", () => {
-        test("is updated", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            expect($derivation.get()).toBe(2);
-
-            $state.set(2);
-            expect($derivation.get()).toBe(4);
-        });
-
-        test("get throws when disposed", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            expect($derivation.get()).toBe(2);
-
-            $state.set(2);
-            expect($derivation.get()).toBe(4);
-
-            $derivation.dispose();
-            expect(() => $derivation.get()).toThrow(
-                "[PicoFlow] Primitive is disposed",
-            );
-        });
-
-        test("get throws when state is disposed", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            expect($derivation.get()).toBe(2);
-
-            $state.set(2);
-            expect($derivation.get()).toBe(4);
-
-            $state.dispose();
-            expect(() => $derivation.get()).toThrow(
-                "[PicoFlow] Primitive is disposed",
-            );
-        });
-
-        test("is updated (chained dependencies)", () => {
-            const $state = state(1);
-            const $derivation1 = derivation((get) => get($state) * 2);
-            const $derivation2 = derivation((get) => get($derivation1) * 2);
-
-            expect($derivation2.get()).toBe(4);
-
-            $state.set(2);
-            expect($derivation2.get()).toBe(8);
-        });
-
-        test("is updated (multiple dependencies)", () => {
-            const $state1 = state(1);
-            const $state2 = state(2);
-            const $derivation = derivation(
-                (get) => get($state1) + get($state2),
-            );
-
-            expect($derivation.get()).toBe(3);
-
-            $state1.set(2);
-            expect($derivation.get()).toBe(4);
-
-            $state2.set(3);
-            expect($derivation.get()).toBe(5);
-        });
-
-        test("is updated (multiple dependants)", () => {
-            const $state = state(1);
-            const $derivation1 = derivation((get) => get($state) * 2);
-            const $derivation2 = derivation((get) => get($state) * 3);
-
-            expect($derivation1.get()).toBe(2);
-            expect($derivation2.get()).toBe(3);
-
-            $state.set(2);
-            expect($derivation1.get()).toBe(4);
-            expect($derivation2.get()).toBe(6);
-
-            $state.set(3);
-            expect($derivation1.get()).toBe(6);
-            expect($derivation2.get()).toBe(9);
-        });
-
-        test("is updated (async)", async () => {
-            const $state = state(1);
-            const $derivation = derivation(async (get) => get($state) * 2);
-
-            expect(await $derivation.get()).toBe(2);
-
-            $state.set(2);
-            expect(await $derivation.get()).toBe(4);
-        });
-
-        test("is updated (async chain)", async () => {
-            const $state = state(1);
-            const $derivation1 = derivation(async (get) => get($state) * 2);
-            const $derivation2 = derivation(
-                async (get) => (await get($derivation1)) * 2,
-            );
-
-            expect(await $derivation2.get()).toBe(4);
-
-            $state.set(2);
-            expect(await $derivation2.get()).toBe(8);
-        });
-    });
-
-    describe("from resource", () => {
-        test("from resource is updated", async () => {
-            let resourceCounter = 0;
-            const fetchResource = async () => {
-                resourceCounter++;
-                return resourceCounter;
-            };
-            const $resource = resource(fetchResource);
-            const $derivation = derivation((get) => (get($resource) ?? 0) * 2);
-
-            expect($derivation.get()).toBe(0);
-
-            await $resource.fetch();
-            expect($derivation.get()).toBe(2);
-
-            await $resource.fetch();
-            expect($derivation.get()).toBe(4);
-
-            await $resource.fetch();
-            expect($derivation.get()).toBe(6);
-        });
-    });
+	describe("from state", () => {
+		test("is updated", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			expect($derivation.pick()).toBe(2);
+
+			$state.set(2);
+			expect($derivation.pick()).toBe(4);
+		});
+
+		test("get throws when disposed", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			expect($derivation.pick()).toBe(2);
+
+			$state.set(2);
+			expect($derivation.pick()).toBe(4);
+
+			$derivation.dispose();
+			expect(() => $derivation.pick()).toThrow(
+				"[PicoFlow] Primitive is disposed",
+			);
+		});
+
+		test("get throws when state is disposed", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			expect($derivation.pick()).toBe(2);
+
+			$state.set(2);
+			expect($derivation.pick()).toBe(4);
+
+			$state.dispose();
+			expect(() => $derivation.pick()).toThrow(
+				"[PicoFlow] Primitive is disposed",
+			);
+		});
+
+		test("is updated (chained dependencies)", () => {
+			const $state = state(1);
+			const $derivation1 = derivation((t) => $state.get(t) * 2);
+			const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+
+			expect($derivation2.pick()).toBe(4);
+
+			$state.set(2);
+			expect($derivation2.pick()).toBe(8);
+		});
+
+		test("is updated (multiple dependencies)", () => {
+			const $state1 = state(1);
+			const $state2 = state(2);
+			const $derivation = derivation((t) => $state1.get(t) + $state2.get(t));
+
+			expect($derivation.pick()).toBe(3);
+
+			$state1.set(2);
+			expect($derivation.pick()).toBe(4);
+
+			$state2.set(3);
+			expect($derivation.pick()).toBe(5);
+		});
+
+		test("is updated (multiple dependants)", () => {
+			const $state = state(1);
+			const $derivation1 = derivation((t) => $state.get(t) * 2);
+			const $derivation2 = derivation((t) => $state.get(t) * 3);
+
+			expect($derivation1.pick()).toBe(2);
+			expect($derivation2.pick()).toBe(3);
+
+			$state.set(2);
+			expect($derivation1.pick()).toBe(4);
+			expect($derivation2.pick()).toBe(6);
+
+			$state.set(3);
+			expect($derivation1.pick()).toBe(6);
+			expect($derivation2.pick()).toBe(9);
+		});
+
+		test("is updated (async)", async () => {
+			const $state = state(1);
+			const $derivation = derivation(async (t) => $state.get(t) * 2);
+
+			expect(await $derivation.pick()).toBe(2);
+
+			$state.set(2);
+			expect(await $derivation.pick()).toBe(4);
+		});
+
+		test("is updated (async chain)", async () => {
+			const $state = state(1);
+			const $derivation1 = derivation(async (t) => $state.get(t) * 2);
+			const $derivation2 = derivation(
+				async (t) => (await $derivation1.get(t)) * 2,
+			);
+
+			expect(await $derivation2.pick()).toBe(4);
+
+			$state.set(2);
+			expect(await $derivation2.pick()).toBe(8);
+		});
+	});
+
+	describe("from resource", () => {
+		test("from resource is updated", async () => {
+			let resourceCounter = 0;
+			const fetchResource = async () => {
+				resourceCounter++;
+				return resourceCounter;
+			};
+			const $resource = resource(fetchResource);
+			const $derivation = derivation((t) => ($resource.get(t) ?? 0) * 2);
+
+			expect($derivation.pick()).toBe(0);
+
+			await $resource.fetch();
+			expect($derivation.pick()).toBe(2);
+
+			await $resource.fetch();
+			expect($derivation.pick()).toBe(4);
+
+			await $resource.fetch();
+			expect($derivation.pick()).toBe(6);
+		});
+	});
 });
 
 describe("effect", () => {
-    describe("from signal", () => {
-        test("called when triggered", () => {
-            const $signal = signal();
-            const $derivation = derivation((_, watch) => {
-                watch($signal);
-            });
-            const effectFn = vi.fn();
-            effect((_, watch) => {
-                watch($derivation);
-                effectFn();
-            });
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(2);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(3);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(4);
-        });
-
-        test("called when triggered (chained dependencies)", () => {
-            const $signal = signal();
-            const $derivation1 = derivation((_, watch) => watch($signal));
-            const $derivation2 = derivation((_, watch) => watch($derivation1));
-            const effectFn = vi.fn();
-            effect((_, watch) => {
-                watch($derivation2);
-                effectFn();
-            });
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(2);
-        });
-
-        test("called when triggered (multiple dependencies)", () => {
-            const $signal1 = signal();
-            const $signal2 = signal();
-            const $derivation = derivation((_, watch) => {
-                watch($signal1);
-                watch($signal2);
-            });
-            const effectFn = vi.fn();
-            effect((_, watch) => {
-                watch($derivation);
-                effectFn();
-            });
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-
-            $signal1.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(2);
-
-            $signal2.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(3);
-        });
-
-        test("called when is updated (multiple dependants)", () => {
-            const $signal = signal();
-            const $derivation1 = derivation((_, watch) => watch($signal));
-            const $derivation2 = derivation((_, watch) => watch($signal));
-            const effect1Fn = vi.fn();
-            const effect2Fn = vi.fn();
-
-            effect((get) => effect1Fn(get($derivation1)));
-            effect((get) => effect2Fn(get($derivation2)));
-
-            expect(effect1Fn).toHaveBeenCalledTimes(1);
-            expect(effect2Fn).toHaveBeenCalledTimes(1);
-
-            $signal.trigger();
-            expect(effect1Fn).toHaveBeenCalledTimes(2);
-            expect(effect2Fn).toHaveBeenCalledTimes(2);
-
-            $signal.trigger();
-            expect(effect1Fn).toHaveBeenCalledTimes(3);
-            expect(effect2Fn).toHaveBeenCalledTimes(3);
-        });
-
-        test("called when triggered (with state)", () => {
-            const $signal = signal();
-            const $state = state(1);
-            const $derivation = derivation((get, watch) => {
-                watch($signal);
-                return get($state) * 2;
-            });
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(3);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(4);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-
-            $signal.trigger();
-            expect(effectFn).toHaveBeenCalledTimes(5);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-        });
-    });
-
-    describe("from state", () => {
-        test("called when is updated", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-        });
-
-        test("called when is updated (chained dependencies)", () => {
-            const $state = state(1);
-            const $derivation1 = derivation((get) => get($state) * 2);
-            const $derivation2 = derivation((get) => get($derivation1) * 2);
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation2)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(8);
-        });
-
-        test("called when is updated (multiple dependencies)", () => {
-            const $state1 = state(1);
-            const $state2 = state(2);
-            const $derivation = derivation(
-                (get) => get($state1) + get($state2),
-            );
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(3);
-
-            $state1.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-
-            $state2.set(3);
-            expect(effectFn).toHaveBeenCalledTimes(3);
-            expect(effectFn).toHaveBeenLastCalledWith(5);
-        });
-
-        test("called when is updated (multiple dependants)", () => {
-            const $state = state(1);
-            const $derivation1 = derivation((get) => get($state) * 2);
-            const $derivation2 = derivation((get) => get($state) * 3);
-            const effect1Fn = vi.fn();
-            const effect2Fn = vi.fn();
-
-            effect((get) => effect1Fn(get($derivation1)));
-            effect((get) => effect2Fn(get($derivation2)));
-
-            expect(effect1Fn).toHaveBeenCalledTimes(1);
-            expect(effect1Fn).toHaveBeenLastCalledWith(2);
-            expect(effect2Fn).toHaveBeenCalledTimes(1);
-            expect(effect2Fn).toHaveBeenLastCalledWith(3);
-
-            $state.set(2);
-            expect(effect1Fn).toHaveBeenCalledTimes(2);
-            expect(effect1Fn).toHaveBeenLastCalledWith(4);
-            expect(effect2Fn).toHaveBeenCalledTimes(2);
-            expect(effect2Fn).toHaveBeenLastCalledWith(6);
-
-            $state.set(3);
-            expect(effect1Fn).toHaveBeenCalledTimes(3);
-            expect(effect1Fn).toHaveBeenLastCalledWith(6);
-            expect(effect2Fn).toHaveBeenCalledTimes(3);
-            expect(effect2Fn).toHaveBeenLastCalledWith(9);
-        });
-
-        test("called when is updated (async)", async () => {
-            const $state = state(1);
-            const $derivation = derivation(async (get) => get($state) * 2);
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(await effectFn.mock.calls[0][0]).toEqual(2);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(await effectFn.mock.calls[1][0]).toEqual(4);
-        });
-
-        test("called when is updated (async chain)", async () => {
-            const $state = state(1);
-            const $derivation1 = derivation(async (get) => get($state) * 2);
-            const $derivation2 = derivation(
-                async (get) => (await get($derivation1)) * 2,
-            );
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation2)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(await effectFn.mock.calls[0][0]).toEqual(4);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(await effectFn.mock.calls[1][0]).toEqual(8);
-        });
-
-        test("NOT called when derivation is disposed", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-
-            $derivation.dispose();
-
-            $state.set(3);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-        });
-
-        test("NOT called when derivation is disposed (watch)", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            const effectFn = vi.fn();
-            effect((_, watch) => {
-                watch($derivation);
-                effectFn();
-            });
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-
-            $derivation.dispose();
-
-            $state.set(3);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-        });
-
-        test("NOT called when disposed", () => {
-            const $state = state(1);
-            const $derivation = derivation((get) => get($state) * 2);
-            const effectFn = vi.fn();
-            const $effect = effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            $state.set(2);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-
-            $effect.dispose();
-
-            $state.set(3);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-        });
-    });
-
-    describe("from resource", () => {
-        test("called when is updated", async () => {
-            let resourceCounter = 0;
-            const fetchResource = async () => {
-                resourceCounter++;
-                return resourceCounter;
-            };
-            const $resource = resource(fetchResource);
-            const $derivation = derivation((get) => (get($resource) ?? 0) * 2);
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(0);
-
-            await $resource.fetch();
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(2);
-
-            await $resource.fetch();
-            expect(effectFn).toHaveBeenCalledTimes(3);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-        });
-    });
-
-    describe("complex test", () => {
-        test("test", () => {
-            const obj1 = {
-                cond: state(false),
-                num: state(2),
-                dispose: (options: { self: boolean }) => {
-                    obj1.cond.dispose(options);
-                    obj1.num.dispose(options);
-                }
-            }
-            const obj2 = {
-                cond: state(false),
-                num: state(4),
-                dispose: (options: { self: boolean }) => {
-                    obj2.cond.dispose(options);
-                    obj2.num.dispose(options);
-                }
-            }
-            const $state = state(obj1);
-            const $derivationCond = derivation((get) => get(get($state).cond));
-            const $derivationNum = derivation((get) => get(get($state).num) * 2);
-            const effectCondFn = vi.fn();
-            const effectNumFn = vi.fn();
-            effect((get) => effectCondFn(get($derivationCond)));
-            effect((get) => effectNumFn(get($derivationNum)));
-
-            expect(effectCondFn).toHaveBeenCalledTimes(1);
-            expect(effectCondFn).toHaveBeenLastCalledWith(false);
-            expect(effectNumFn).toHaveBeenCalledTimes(1);
-            expect(effectNumFn).toHaveBeenLastCalledWith(4);
-
-            $state.get().num.set(3);
-            expect(effectCondFn).toHaveBeenCalledTimes(1);
-            expect(effectCondFn).toHaveBeenLastCalledWith(false);
-            expect(effectNumFn).toHaveBeenCalledTimes(2);
-            expect(effectNumFn).toHaveBeenLastCalledWith(6);
-
-            $state.get().cond.set(true);
-            expect(effectCondFn).toHaveBeenCalledTimes(2);
-            expect(effectCondFn).toHaveBeenLastCalledWith(true);
-            expect(effectNumFn).toHaveBeenCalledTimes(2);
-            expect(effectNumFn).toHaveBeenLastCalledWith(6);
-
-            $state.set(obj2)
-            expect(effectCondFn).toHaveBeenCalledTimes(3);
-            expect(effectCondFn).toHaveBeenLastCalledWith(false);
-            expect(effectNumFn).toHaveBeenCalledTimes(3);
-            expect(effectNumFn).toHaveBeenLastCalledWith(8);
-
-            $state.get().cond.set(true);
-            expect(effectCondFn).toHaveBeenCalledTimes(4); // fails -> called 3 times
-            expect(effectCondFn).toHaveBeenLastCalledWith(true);
-            expect(effectNumFn).toHaveBeenCalledTimes(3);
-            expect(effectNumFn).toHaveBeenLastCalledWith(8);
-
-            $state.get().num.set(5);
-            expect(effectCondFn).toHaveBeenCalledTimes(4);
-            expect(effectCondFn).toHaveBeenLastCalledWith(true);
-            expect(effectNumFn).toHaveBeenCalledTimes(4);
-            expect(effectNumFn).toHaveBeenLastCalledWith(10);
-        });
-
-        test("test", () => {
-            const obj = {
-                cond: state(false),
-                b: state(2)
-            }
-
-            const $state = state(obj);
-            const $derivation = derivation((get) => {
-                const cond = get(get($state).cond);
-                if (cond) {
-                    return get(get($state).b) * 2;
-                }
-                return 0;
-            });
-
-
-            const effectFn = vi.fn();
-            effect((get) => effectFn(get($derivation)));
-
-            expect(effectFn).toHaveBeenCalledTimes(1);
-            expect(effectFn).toHaveBeenLastCalledWith(0);
-
-            $state.get().cond.set(true);
-            expect(effectFn).toHaveBeenCalledTimes(2);
-            expect(effectFn).toHaveBeenLastCalledWith(4);
-
-            $state.set({ cond: state(false), b: state(3) })
-            expect(effectFn).toHaveBeenCalledTimes(3);
-            expect(effectFn).toHaveBeenLastCalledWith(0);
-
-            $state.get().cond.set(true);
-            expect(effectFn).toHaveBeenCalledTimes(4);
-            expect(effectFn).toHaveBeenLastCalledWith(6);
-        });
-    });
+	describe("from signal", () => {
+		test("called when triggered", () => {
+			const $signal = signal();
+			const $derivation = derivation((t) => {
+				$signal.watch(t);
+			});
+			const effectFn = vi.fn();
+			effect((t) => {
+				$derivation.watch(t);
+				effectFn();
+			});
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(2);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(3);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(4);
+		});
+
+		test("called when triggered (chained dependencies)", () => {
+			const $signal = signal();
+			const $derivation1 = derivation((t) => $signal.watch(t));
+			const $derivation2 = derivation((t) => $derivation1.watch(t));
+			const effectFn = vi.fn();
+			effect((t) => {
+				$derivation2.watch(t);
+				effectFn();
+			});
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(2);
+		});
+
+		test("called when triggered (multiple dependencies)", () => {
+			const $signal1 = signal();
+			const $signal2 = signal();
+			const $derivation = derivation((t) => {
+				$signal1.watch(t);
+				$signal2.watch(t);
+			});
+			const effectFn = vi.fn();
+			effect((t) => {
+				$derivation.watch(t);
+				effectFn();
+			});
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+
+			$signal1.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(2);
+
+			$signal2.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(3);
+		});
+
+		test("called when is updated (multiple dependants)", () => {
+			const $signal = signal();
+			const $derivation1 = derivation((t) => $signal.watch(t));
+			const $derivation2 = derivation((t) => $signal.watch(t));
+			const effect1Fn = vi.fn();
+			const effect2Fn = vi.fn();
+
+			effect((t) => effect1Fn($derivation1.get(t)));
+			effect((t) => effect2Fn($derivation2.get(t)));
+
+			expect(effect1Fn).toHaveBeenCalledTimes(1);
+			expect(effect2Fn).toHaveBeenCalledTimes(1);
+
+			$signal.trigger();
+			expect(effect1Fn).toHaveBeenCalledTimes(2);
+			expect(effect2Fn).toHaveBeenCalledTimes(2);
+
+			$signal.trigger();
+			expect(effect1Fn).toHaveBeenCalledTimes(3);
+			expect(effect2Fn).toHaveBeenCalledTimes(3);
+		});
+
+		test("called when triggered (with state)", () => {
+			const $signal = signal();
+			const $state = state(1);
+			const $derivation = derivation((t) => {
+				$signal.watch(t);
+				return $state.get(t) * 2;
+			});
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(3);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(4);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+
+			$signal.trigger();
+			expect(effectFn).toHaveBeenCalledTimes(5);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+		});
+	});
+
+	describe("from state", () => {
+		test("called when is updated", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+		});
+
+		test("called when is updated (chained dependencies)", () => {
+			const $state = state(1);
+			const $derivation1 = derivation((t) => $state.get(t) * 2);
+			const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation2.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(8);
+		});
+
+		test("called when is updated (multiple dependencies)", () => {
+			const $state1 = state(1);
+			const $state2 = state(2);
+			const $derivation = derivation((t) => $state1.get(t) + $state2.get(t));
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(3);
+
+			$state1.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+
+			$state2.set(3);
+			expect(effectFn).toHaveBeenCalledTimes(3);
+			expect(effectFn).toHaveBeenLastCalledWith(5);
+		});
+
+		test("called when is updated (multiple dependants)", () => {
+			const $state = state(1);
+			const $derivation1 = derivation((t) => $state.get(t) * 2);
+			const $derivation2 = derivation((t) => $state.get(t) * 3);
+			const effect1Fn = vi.fn();
+			const effect2Fn = vi.fn();
+
+			effect((t) => effect1Fn($derivation1.get(t)));
+			effect((t) => effect2Fn($derivation2.get(t)));
+
+			expect(effect1Fn).toHaveBeenCalledTimes(1);
+			expect(effect1Fn).toHaveBeenLastCalledWith(2);
+			expect(effect2Fn).toHaveBeenCalledTimes(1);
+			expect(effect2Fn).toHaveBeenLastCalledWith(3);
+
+			$state.set(2);
+			expect(effect1Fn).toHaveBeenCalledTimes(2);
+			expect(effect1Fn).toHaveBeenLastCalledWith(4);
+			expect(effect2Fn).toHaveBeenCalledTimes(2);
+			expect(effect2Fn).toHaveBeenLastCalledWith(6);
+
+			$state.set(3);
+			expect(effect1Fn).toHaveBeenCalledTimes(3);
+			expect(effect1Fn).toHaveBeenLastCalledWith(6);
+			expect(effect2Fn).toHaveBeenCalledTimes(3);
+			expect(effect2Fn).toHaveBeenLastCalledWith(9);
+		});
+
+		test("called when is updated (async)", async () => {
+			const $state = state(1);
+			const $derivation = derivation(async (t) => $state.get(t) * 2);
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(await effectFn.mock.calls[0][0]).toEqual(2);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(await effectFn.mock.calls[1][0]).toEqual(4);
+		});
+
+		test("called when is updated (async chain)", async () => {
+			const $state = state(1);
+			const $derivation1 = derivation(async (t) => $state.get(t) * 2);
+			const $derivation2 = derivation(
+				async (t) => (await $derivation1.get(t)) * 2,
+			);
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation2.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(await effectFn.mock.calls[0][0]).toEqual(4);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(await effectFn.mock.calls[1][0]).toEqual(8);
+		});
+
+		test("NOT called when derivation is disposed", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+
+			$derivation.dispose();
+
+			$state.set(3);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+		});
+
+		test("NOT called when derivation is disposed (watch)", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			const effectFn = vi.fn();
+			effect((t) => {
+				$derivation.watch(t);
+				effectFn();
+			});
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+
+			$derivation.dispose();
+
+			$state.set(3);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+		});
+
+		test("NOT called when disposed", () => {
+			const $state = state(1);
+			const $derivation = derivation((t) => $state.get(t) * 2);
+			const effectFn = vi.fn();
+			const $effect = effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			$state.set(2);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+
+			$effect.dispose();
+
+			$state.set(3);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+		});
+	});
+
+	describe("from resource", () => {
+		test("called when is updated", async () => {
+			let resourceCounter = 0;
+			const fetchResource = async () => {
+				resourceCounter++;
+				return resourceCounter;
+			};
+			const $resource = resource(fetchResource);
+			const $derivation = derivation((t) => ($resource.get(t) ?? 0) * 2);
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(0);
+
+			await $resource.fetch();
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(2);
+
+			await $resource.fetch();
+			expect(effectFn).toHaveBeenCalledTimes(3);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+		});
+	});
+
+	describe("complex test", () => {
+		test("test", () => {
+			const obj1 = {
+				cond: state(false),
+				num: state(2),
+				dispose: (options: { self: boolean }) => {
+					obj1.cond.dispose(options);
+					obj1.num.dispose(options);
+				},
+			};
+			const obj2 = {
+				cond: state(false),
+				num: state(4),
+				dispose: (options: { self: boolean }) => {
+					obj2.cond.dispose(options);
+					obj2.num.dispose(options);
+				},
+			};
+			const $state = state(obj1);
+			const $derivationCond = derivation((t) => $state.get(t).cond.get(t));
+			const $derivationNum = derivation((t) => $state.get(t).num.get(t) * 2);
+			const effectCondFn = vi.fn();
+			const effectNumFn = vi.fn();
+			effect((t) => effectCondFn($derivationCond.get(t)));
+			effect((t) => effectNumFn($derivationNum.get(t)));
+
+			expect(effectCondFn).toHaveBeenCalledTimes(1);
+			expect(effectCondFn).toHaveBeenLastCalledWith(false);
+			expect(effectNumFn).toHaveBeenCalledTimes(1);
+			expect(effectNumFn).toHaveBeenLastCalledWith(4);
+
+			$state.pick().num.set(3);
+			expect(effectCondFn).toHaveBeenCalledTimes(1);
+			expect(effectCondFn).toHaveBeenLastCalledWith(false);
+			expect(effectNumFn).toHaveBeenCalledTimes(2);
+			expect(effectNumFn).toHaveBeenLastCalledWith(6);
+
+			$state.pick().cond.set(true);
+			expect(effectCondFn).toHaveBeenCalledTimes(2);
+			expect(effectCondFn).toHaveBeenLastCalledWith(true);
+			expect(effectNumFn).toHaveBeenCalledTimes(2);
+			expect(effectNumFn).toHaveBeenLastCalledWith(6);
+
+			$state.set(obj2);
+			expect(effectCondFn).toHaveBeenCalledTimes(3);
+			expect(effectCondFn).toHaveBeenLastCalledWith(false);
+			expect(effectNumFn).toHaveBeenCalledTimes(3);
+			expect(effectNumFn).toHaveBeenLastCalledWith(8);
+
+			$state.pick().cond.set(true);
+			expect(effectCondFn).toHaveBeenCalledTimes(4); // fails -> called 3 times
+			expect(effectCondFn).toHaveBeenLastCalledWith(true);
+			expect(effectNumFn).toHaveBeenCalledTimes(3);
+			expect(effectNumFn).toHaveBeenLastCalledWith(8);
+
+			$state.pick().num.set(5);
+			expect(effectCondFn).toHaveBeenCalledTimes(4);
+			expect(effectCondFn).toHaveBeenLastCalledWith(true);
+			expect(effectNumFn).toHaveBeenCalledTimes(4);
+			expect(effectNumFn).toHaveBeenLastCalledWith(10);
+		});
+
+		test("test", () => {
+			const obj = {
+				cond: state(false),
+				b: state(2),
+			};
+
+			const $state = state(obj);
+			const $derivation = derivation((t) => {
+				const cond = $state.get(t).cond.get(t);
+				if (cond) {
+					return $state.get(t).b.get(t) * 2;
+				}
+				return 0;
+			});
+
+			const effectFn = vi.fn();
+			effect((t) => effectFn($derivation.get(t)));
+
+			expect(effectFn).toHaveBeenCalledTimes(1);
+			expect(effectFn).toHaveBeenLastCalledWith(0);
+
+			$state.pick().cond.set(true);
+			expect(effectFn).toHaveBeenCalledTimes(2);
+			expect(effectFn).toHaveBeenLastCalledWith(4);
+
+			$state.set({ cond: state(false), b: state(3) });
+			expect(effectFn).toHaveBeenCalledTimes(3);
+			expect(effectFn).toHaveBeenLastCalledWith(0);
+
+			$state.pick().cond.set(true);
+			expect(effectFn).toHaveBeenCalledTimes(4);
+			expect(effectFn).toHaveBeenLastCalledWith(6);
+		});
+	});
 });