@ersbeth/picoflow 1.0.1 → 1.1.1

package/test/derivation.test.ts

@@ -1,539 +0,0 @@
-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((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((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);
-		});
-	});
-});

package/test/effect.test.ts

@@ -1,29 +0,0 @@
-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((t) => {
-			$signal.watch(t);
-			effectFn();
-		});
-
-		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((t) => {
-			$signal.watch(t);
-			effectFn();
-		});
-
-		$effect.dispose();
-		expect(() => $effect.dispose()).toThrow("Effect is disposed");
-	});
-});