@ersbeth/picoflow 2.0.2 → 2.0.3

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

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