@ersbeth/picoflow 2.0.1 → 2.0.3

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

@@ -1,603 +0,0 @@
-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

@@ -1,10 +0,0 @@
-// 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,37 +0,0 @@
-{
-    "compilerOptions": {
-        "rootDir": ".",
-        "target": "ESNext",
-
-        "module": "ESNext",
-        "moduleResolution": "Bundler",
-        "skipLibCheck": true,
-
-        "declaration": true,
-        "declarationMap": true,
-        "outDir": "dist/types",
-
-        "isolatedModules": true,
-        "allowSyntheticDefaultImports": true,
-        "esModuleInterop": true,
-
-        "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/**/*"]
-}

package/typedoc.json

@@ -1,37 +0,0 @@
-{
-    "$schema": "https://typedoc.org/schema.json",
-    "entryPoints": ["src/index.ts"],
-    "entryPointStrategy": "resolve",
-    "out": "docs/api",
-    "docsRoot": "docs",
-    "plugin": ["typedoc-plugin-markdown", "typedoc-vitepress-theme"],
-    "readme": "none",
-    "hideGenerator": true,
-    "cleanOutputDir": true,
-    "excludePrivate": true,
-    "excludeProtected": true,
-    "excludeExternals": true,
-    "excludeInternal": true,
-    "entryFileName": "index.md",
-    "hidePageHeader": true,
-    "hideBreadcrumbs": false,
-    "useCodeBlocks": true,
-    "expandObjects": true,
-    "parametersFormat": "table",
-    "propertiesFormat": "table",
-    "enumMembersFormat": "table",
-    "typeDeclarationFormat": "table",
-    "indexFormat": "table",
-    "outputFileStrategy": "members",
-    "flattenOutputFiles": false,
-    "fileExtension": ".md",
-    "publicPath": "/api/",
-    "textContentMappings": {
-        "header.title": "API Reference"
-    },
-    "externalSymbolLinkMappings": {
-        "@ersbeth/picoflow": {
-            "FlowObservable._getRaw": "#"
-        }
-    }
-}