@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/reactivity/nodes/sync/flowWritableDerivation.test.ts

@@ -0,0 +1,603 @@
+import { describe, expect, it, vi } from "vitest";
+import { derivation, signal, state, subscribe, writableDerivation } from "~";
+
+describe("flowWritableDerivation", () => {
+    describe("unit", () => {
+        describe("set on derivation", () => {
+            it("should override computed value when set is called", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should notify dependents when set overrides computed value", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(100);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should work with updater function on writableDerivation with dependencies", async () => {
+                const $state = state(5);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set((current) => (current ?? 0) + 5);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("should not notify when set with same value on writableDerivation", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(2);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+        });
+
+        describe("set and reactive dependencies", () => {
+            it("should recompute when dependency changes after set", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+
+                $state.set(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 = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $writableDerivation = writableDerivation(computeFn);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(5);
+                // When accessed, it should recompute because dependency changed
+                expect(await $writableDerivation.pick()).toBe(10);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should handle set after dependency change", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(5);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(200);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(200);
+            });
+
+            it("should handle set then dependency change then refresh", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $writableDerivation = writableDerivation(computeFn);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(5);
+                $writableDerivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+                expect(await $writableDerivation.pick()).toBe(10);
+            });
+        });
+
+        describe("set with different statuses", () => {
+            it("should work when set is called on dirty derivation", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+
+                await $writableDerivation.pick();
+                $state.set(5);
+                // Now derivation is dirty
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should work when set is called on pending derivation", async () => {
+                const $state = state(1);
+                const promise = Promise.resolve(2);
+                const $writableDerivation = writableDerivation((t) => {
+                    const value = $state.get(t);
+                    if (value === 2) {
+                        throw promise;
+                    }
+                    return value * 2;
+                });
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $state.set(2);
+                // Now derivation is pending
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should work when set is called on error derivation", async () => {
+                const $state = state(1);
+                const error = new Error("Compute error");
+                const $writableDerivation = writableDerivation((t) => {
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value * 2;
+                });
+
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $state.set(2);
+                // Now derivation is in error state
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+
+            it("should work when set is called on resolved derivation with dependencies", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+
+                await $writableDerivation.pick();
+                // Now derivation is resolved
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+            });
+        });
+
+        describe("set and refresh interaction", () => {
+            it("should override set value when refresh is called", async () => {
+                const $state = state(5);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(100);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(100);
+
+                $writableDerivation.refresh();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(10);
+            });
+
+            it("should override refresh value when set is called after refresh", async () => {
+                const $state = state(5);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+
+                $writableDerivation.set(200);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(200);
+            });
+
+            it("should handle set then refresh then dependency change", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $writableDerivation = writableDerivation(computeFn);
+
+                expect(await $writableDerivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $writableDerivation.set(100);
+                expect(await $writableDerivation.pick()).toBe(100);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $writableDerivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+                expect(await $writableDerivation.pick()).toBe(2);
+
+                $state.set(5);
+                expect(await $writableDerivation.pick()).toBe(10);
+                expect(computeFn).toHaveBeenCalledTimes(3);
+            });
+        });
+
+        describe("set with computed dependencies", () => {
+            it("should work with set on writableDerivation depending on another derivation", async () => {
+                const $state = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $writableDerivation = writableDerivation((t) => $derivation1.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $writableDerivation.set(100);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should work with set on writableDerivation depending on state", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(50);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(50);
+            });
+
+            it("should work with set on writableDerivation depending on signal", async () => {
+                const $signal = signal();
+                const $state = state(0);
+                const $writableDerivation = writableDerivation((t) => {
+                    $signal.watch(t);
+                    return $state.get(t);
+                });
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(0);
+
+                $writableDerivation.set(99);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(99);
+            });
+
+            it("should work with set on writableDerivation with multiple dependencies", async () => {
+                const $state1 = state(1);
+                const $state2 = state(2);
+                const $writableDerivation = writableDerivation((t) => $state1.get(t) + $state2.get(t));
+                const onData = vi.fn();
+
+                $writableDerivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $writableDerivation.set(999);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                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 = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (data) => {
+                        if (data === 2) {
+                            $writableDerivation.set(100);
+                        }
+                        onData(data);
+                    },
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenNthCalledWith(1, 2);
+                expect(onData).toHaveBeenNthCalledWith(2, 100);
+            });
+
+            it("should work when one effect observes and another effect does set", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const observerFn = vi.fn();
+                const setterFn = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (data) => observerFn(data),
+                );
+
+                subscribe(
+                    () => undefined,
+                    () => {
+                        $writableDerivation.set(200);
+                        setterFn();
+                    },
+                );
+
+                await vi.waitFor(() => expect(observerFn).toHaveBeenCalledTimes(2));
+                expect(observerFn).toHaveBeenNthCalledWith(1, 2);
+                expect(observerFn).toHaveBeenNthCalledWith(2, 200);
+                expect(setterFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should work when dependency changes then set is done", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (data) => {
+                        if (data === 4) {
+                            $writableDerivation.set(300);
+                        }
+                        onData(data);
+                    },
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(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(2));
+                expect(onData).toHaveBeenNthCalledWith(2, 4);
+                // 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 = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (data) => onData(data),
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(5);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $writableDerivation.set(400);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(400);
+            });
+
+            it("should handle set then dependency change", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (data) => onData(data),
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(500);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(500);
+
+                $state.set(10);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should handle set then dependency change then refresh", async () => {
+                const $state = state(1);
+                const $writableDerivation = writableDerivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => $writableDerivation.get(t),
+                    (data) => onData(data),
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $writableDerivation.set(600);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(600);
+
+                $state.set(20);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                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 = state(1);
+                const $writableDerivation1 = writableDerivation((t) => $state.get(t) * 2);
+                const $writableDerivation2 = writableDerivation((t) => $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(10);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should work with set on parent writableDerivation", async () => {
+                const $state = state(1);
+                const $writableDerivation1 = writableDerivation((t) => $state.get(t) * 2);
+                const $writableDerivation2 = writableDerivation((t) => $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(50);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should work with set on child writableDerivation", async () => {
+                const $state = state(1);
+                const $writableDerivation1 = writableDerivation((t) => $state.get(t) * 2);
+                const $writableDerivation2 = writableDerivation((t) => $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(999);
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(2);
+                });
+                expect(onData2).toHaveBeenLastCalledWith(999);
+            });
+        });
+
+        describe("complex patterns with set", () => {
+            it("should handle diamond pattern with writableDerivations and set", async () => {
+                const $stateA = state(1);
+                const $aMult3 = writableDerivation((t) => $stateA.get(t) * 3);
+                const $aMult2 = writableDerivation((t) => $stateA.get(t) * 2);
+                const $addAmult3Amult2 = writableDerivation((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(100);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(102);
+            });
+
+            it("should handle writableDerivation with conditional dependencies and set", async () => {
+                const $state1 = state(1);
+                const $state2 = state(10);
+                const $cond = state(true);
+                const $writableDerivation = writableDerivation((t) => {
+                    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(777);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(777);
+
+                $cond.set(false);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should handle set on writableDerivation in complex pattern", async () => {
+                const $stateA = state(1);
+                const $stateB = state(2);
+                const $addAB = writableDerivation((t) => {
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a + b;
+                });
+                const $multiplyAB = writableDerivation((t) => {
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a * b;
+                });
+                const $addAndMultiply = writableDerivation((t) => {
+                    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(100);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(200);
+            });
+        });
+    });
+});

package/test/vitest.d.ts

@@ -0,0 +1,10 @@
+// biome-ignore lint/correctness/noUnusedImports: we need to extend the ExpectStatic interface to override the element matcher
+import type { ExpectStatic } from "vitest";
+
+declare module "vitest" {
+    interface ExpectStatic {
+        element(element: Element | null): {
+            toBeInTheDocument(): Promise<void>;
+        };
+    }
+}

package/tsconfig.json

@@ -1,26 +1,37 @@
 {
-	"compilerOptions": {
-		"rootDir": ".",
-		"target": "ESNext",
+    "compilerOptions": {
+        "rootDir": ".",
+        "target": "ESNext",
 
-		"module": "ESNext",
-		"moduleResolution": "Bundler",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "skipLibCheck": true,
 
-		"declaration": true,
-		"declarationMap": true,
-		"outDir": "dist/types",
-		"skipLibCheck": true,
+        "declaration": true,
+        "declarationMap": true,
+        "outDir": "dist/types",
 
-		"strict": true,
-		"verbatimModuleSyntax": true,
-		"noUnusedLocals": true,
-		"noUnusedParameters": true,
-		"noFallthroughCasesInSwitch": true,
-		"noImplicitOverride": true,
-		"noImplicitReturns": true,
+        "isolatedModules": true,
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
 
-		"stripInternal": true
-	},
-	"include": ["./src/**/*", "./test/**/*"],
-	"exclude": ["./src/flow/nodes/await/**/*", "./test/nodes/await/**/*"]
+        "jsx": "preserve",
+        "jsxImportSource": "solid-js",
+
+        "strict": true,
+        "verbatimModuleSyntax": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitOverride": true,
+        "noImplicitReturns": true,
+
+        "stripInternal": true,
+
+        "paths": {
+            "~": ["./src"],
+            "~/*": ["./src/*"]
+        }
+    },
+    "include": ["./src/**/*", "./test/**/*"]
 }