@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/reactivity/nodes/async/flowWritableDerivationAsync.test.ts

@@ -0,0 +1,614 @@
+import { describe, expect, it, vi } from "vitest";
+import { derivationAsync, signal, stateAsync, subscribe, writableDerivationAsync } from "~";
+
+describe("flowWritableDerivationAsync", () => {
+    describe("unit", () => {
+        describe("set on derivation", () => {
+            it("should override computed value when set is called", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should notify dependents when set overrides computed value", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(Promise.resolve(100));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should work with updater function on writableDerivation with dependencies", async () => {
+                const $state = stateAsync(Promise.resolve(5));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(async (current) => Promise.resolve((current ?? 0) + 5));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("should not notify when set with same value on writableDerivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(Promise.resolve(2));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(3);
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+        });
+
+        describe("set and reactive dependencies", () => {
+            it("should recompute when dependency changes after set", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+
+                $state.set(Promise.resolve(5));
+                // When dependency changes, derivation is marked dirty and recomputes on access
+                expect(await $writableDerivation.pick()).toBe(10);
+            });
+
+            it("should override set value when dependency changes and derivation is accessed", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => (await $state.get(t)) * 2);
+                const $writableDerivation = writableDerivationAsync(computeFn);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(5));
+                // When accessed, it should recompute because dependency changed
+                expect(await $writableDerivation.pick()).toBe(10);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+
+            it("should handle set after dependency change", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(5));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(Promise.resolve(200));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(200);
+            });
+
+            it("should handle set then dependency change then refresh", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $writableDerivation = writableDerivationAsync(computeFn);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(5));
+                $writableDerivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                expect(computeFn).toHaveBeenCalledTimes(4);
+                expect(await $writableDerivation.pick()).toBe(10);
+            });
+        });
+
+        describe("set with different statuses", () => {
+            it("should work when set is called on dirty derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+
+                await $writableDerivation.pick();
+                $state.set(Promise.resolve(5));
+                // Now derivation is dirty
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should work when set is called on pending derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const promise = Promise.resolve(2);
+                const $writableDerivation = writableDerivationAsync(async (t) => {
+                    const value = await $state.get(t);
+                    if (value === 2) {
+                        throw promise;
+                    }
+                    return value * 2;
+                });
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $state.set(Promise.resolve(2));
+                // Now derivation is pending
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should work when set is called on error derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const error = new Error("Compute error");
+                const $writableDerivation = writableDerivationAsync(async (t) => {
+                    const value = await $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value * 2;
+                });
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $state.set(Promise.resolve(2));
+                // Now derivation is in error state
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should work when set is called on resolved derivation with dependencies", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+
+                await $writableDerivation.pick();
+                // Now derivation is resolved
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+        });
+
+        describe("set and refresh interaction", () => {
+            it("should override set value when refresh is called", async () => {
+                const $state = stateAsync(Promise.resolve(5));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(Promise.resolve(100));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(100);
+
+                $writableDerivation.refresh();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(10);
+            });
+
+            it("should override refresh value when set is called after refresh", async () => {
+                const $state = stateAsync(Promise.resolve(5));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(Promise.resolve(200));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(200);
+            });
+
+            it("should handle set then refresh then dependency change", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => (await $state.get(t)) * 2);
+                const $writableDerivation = writableDerivationAsync(computeFn);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $writableDerivation.set(Promise.resolve(100));
+                expect(await $writableDerivation.pick()).toBe(100);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $writableDerivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                expect(computeFn).toHaveBeenCalledTimes(3);
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $state.set(Promise.resolve(5));
+                expect(await $writableDerivation.pick()).toBe(10);
+                expect(computeFn).toHaveBeenCalledTimes(5);
+            });
+        });
+
+        describe("set with computed dependencies", () => {
+            it("should work with set on writableDerivation depending on another derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $writableDerivation = writableDerivationAsync(async (t) => $derivation1.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $writableDerivation.set(Promise.resolve(100));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should work with set on writableDerivation depending on state", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(Promise.resolve(50));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(50);
+            });
+
+            it("should work with set on writableDerivation depending on signal", async () => {
+                const $signal = signal();
+                const $state = stateAsync(Promise.resolve(0));
+                const $writableDerivation = writableDerivationAsync(async (t) => {
+                    await Promise.resolve();
+                    $signal.watch(t);
+                    return $state.get(t);
+                });
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(0);
+
+                $writableDerivation.set(Promise.resolve(99));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(99);
+            });
+
+            it("should work with set on writableDerivation with multiple dependencies", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(2));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state1.get(t) + $state2.get(t));
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $writableDerivation.set(Promise.resolve(999));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(999);
+            });
+        });
+    });
+
+    describe("with effect", () => {
+        describe("set in reactive context", () => {
+            it("should work when effect does set on writableDerivation with dependencies", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (value) => {
+                        if (value === 2) {
+                            $writableDerivation.set(Promise.resolve(100));
+                        }
+                        onData(value);
+                    },
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenNthCalledWith(1, 2);
+                expect(onData).toHaveBeenNthCalledWith(2, 100);
+            });
+
+            // TODO: should we do this ?
+            // it("should work when one effect observes and another effect does set", async () => {
+            // 	const $state = stateAsync(Promise.resolve(1));
+            // 	const $writableDerivation = writableDerivationAsync(
+            // 		async (t) => $state.get(t) * 2,
+            // 	);
+            // 	const observerFn = vi.fn();
+            // 	const setterFn = vi.fn();
+
+            // 	subscribe(
+            // 		(t) => $writableDerivation.get(t),
+            // 		(value) => observerFn(value),
+            // 	);
+
+            // 	subscribe(
+            // 		() => undefined,
+            // 		() => {
+            // 			$writableDerivation.set(Promise.resolve(200));
+            // 			setterFn();
+            // 		},
+            // 	);
+
+            // 	await vi.waitFor(() => expect(observerFn).toHaveBeenCalledTimes(1));
+            // 	expect(observerFn).toHaveBeenLastCalledWith(200);
+            // 	expect(setterFn).toHaveBeenCalledTimes(1);
+            // });
+
+            // TODO: should we do this ?
+            // it("should work when dependency changes then set is done", async () => {
+            // 	const $state = stateAsync(Promise.resolve(1));
+            // 	const $writableDerivation = writableDerivationAsync(
+            // 		async (t) => (await $state.get(t)) * 2,
+            // 	);
+            // 	const onData = vi.fn();
+
+            // 	subscribe(
+            // 		(t) => $writableDerivation.get(t),
+            // 		(value) => {
+            // 			if (value === 4) {
+            // 				$writableDerivation.set(Promise.resolve(300));
+            // 			}
+            // 			onData(value);
+            // 		},
+            // 	);
+
+            // 	await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            // 	expect(onData).toHaveBeenLastCalledWith(2);
+
+            // 	$state.set(Promise.resolve(2));
+            // 	// Effect runs when dependency changes (value 4), set(300) is called in the effect
+            // 	// The set may not trigger another effect run in the same execution cycle
+            // 	await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+            // 	expect(onData).toHaveBeenLastCalledWith(300);
+            // 	// Verify that set was applied
+            // 	expect(await $writableDerivation.pick()).toBe(300);
+            // });
+        });
+
+        describe("set and dependency changes", () => {
+            it("should handle dependency change then set", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $writableDerivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(5));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(Promise.resolve(400));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(400);
+            });
+
+            it("should handle set then dependency change", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $writableDerivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(Promise.resolve(500));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(500);
+
+                $state.set(Promise.resolve(10));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should handle set then dependency change then refresh", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $writableDerivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(Promise.resolve(600));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(600);
+
+                $state.set(Promise.resolve(20));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(40);
+
+                $writableDerivation.refresh();
+                // Refresh may not trigger notification if value is same
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Value should still be 40 after refresh
+                expect(await $writableDerivation.pick()).toBe(40);
+            });
+        });
+
+        describe("nested writable derivations", () => {
+            it("should work with writableDerivation depending on another writableDerivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation1 = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const $writableDerivation2 = writableDerivationAsync(
+                    async (t) => (await $writableDerivation1.get(t)) * 2,
+                );
+                const onData = vi.fn();
+
+                subscribe((t) => $writableDerivation2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $writableDerivation1.set(Promise.resolve(10));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should work with set on parent writableDerivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation1 = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const $writableDerivation2 = writableDerivationAsync(
+                    async (t) => (await $writableDerivation1.get(t)) * 2,
+                );
+                const onData = vi.fn();
+
+                subscribe((t) => $writableDerivation2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $writableDerivation1.set(Promise.resolve(50));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should work with set on child writableDerivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $writableDerivation1 = writableDerivationAsync(async (t) => (await $state.get(t)) * 2);
+                const $writableDerivation2 = writableDerivationAsync(
+                    async (t) => (await $writableDerivation1.get(t)) * 2,
+                );
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+
+                subscribe((t) => $writableDerivation1.get(t), onData1);
+                subscribe((t) => $writableDerivation2.get(t), onData2);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                });
+                expect(onData1).toHaveBeenLastCalledWith(2);
+                expect(onData2).toHaveBeenLastCalledWith(4);
+
+                $writableDerivation2.set(Promise.resolve(999));
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(3);
+                });
+                expect(onData2).toHaveBeenLastCalledWith(999);
+            });
+        });
+
+        describe("complex patterns with set", () => {
+            it("should handle diamond pattern with writableDerivations and set", async () => {
+                const $stateA = stateAsync(Promise.resolve(1));
+                const $aMult3 = writableDerivationAsync(async (t) => $stateA.get(t) * 3);
+                const $aMult2 = writableDerivationAsync(async (t) => $stateA.get(t) * 2);
+                const $addAmult3Amult2 = writableDerivationAsync(async (t) => $aMult3.get(t) + $aMult2.get(t));
+                const onData = vi.fn();
+
+                subscribe((t) => $addAmult3Amult2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(5);
+
+                $aMult3.set(Promise.resolve(100));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(102);
+            });
+
+            it("should handle writableDerivation with conditional dependencies and set", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(10));
+                const $cond = stateAsync(Promise.resolve(true));
+                const $writableDerivation = writableDerivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if ($cond.get(t)) {
+                        return $state1.get(t) * 2;
+                    }
+                    return $state2.get(t) * 2;
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $writableDerivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(Promise.resolve(777));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(777);
+
+                $cond.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should handle set on writableDerivation in complex pattern", async () => {
+                const $stateA = stateAsync(Promise.resolve(1));
+                const $stateB = stateAsync(Promise.resolve(2));
+                const $addAB = writableDerivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a + b;
+                });
+                const $multiplyAB = writableDerivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a * b;
+                });
+                const $addAndMultiply = writableDerivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const add = $addAB.get(t);
+                    const multiply = $multiplyAB.get(t);
+                    return add * multiply;
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $addAndMultiply.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(6);
+
+                $addAB.set(Promise.resolve(100));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(200);
+            });
+        });
+    });
+});