@ersbeth/picoflow 0.0.1 → 0.2.0

package/test/derivation.test.ts

@@ -21,7 +21,9 @@ describe("derivation", () => {
             expect($derivation.get()).toBe(4);
 
             $derivation.dispose();
-            expect(() => $derivation.get()).toThrow("Effect is disposed");
+            expect(() => $derivation.get()).toThrow(
+                "[PicoFlow] Primitive is disposed",
+            );
         });
 
         test("get throws when state is disposed", () => {
@@ -33,7 +35,9 @@ describe("derivation", () => {
             expect($derivation.get()).toBe(4);
 
             $state.dispose();
-            expect(() => $derivation.get()).toThrow("Effect is disposed");
+            expect(() => $derivation.get()).toThrow(
+                "[PicoFlow] Primitive is disposed",
+            );
         });
 
         test("is updated (chained dependencies)", () => {
@@ -111,8 +115,8 @@ describe("derivation", () => {
                 resourceCounter++;
                 return resourceCounter;
             };
-            const $resource = resource(fetchResource, 0);
-            const $derivation = derivation((get) => get($resource) * 2);
+            const $resource = resource(fetchResource);
+            const $derivation = derivation((get) => (get($resource) ?? 0) * 2);
 
             expect($derivation.get()).toBe(0);
 
@@ -374,6 +378,26 @@ describe("effect", () => {
             expect(effectFn).toHaveBeenLastCalledWith(4);
         });
 
+        test("NOT called when derivation is disposed (watch)", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            const effectFn = vi.fn();
+            effect((_, watch) => {
+                watch($derivation);
+                effectFn();
+            });
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+
+            $derivation.dispose();
+
+            $state.set(3);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+        });
+
         test("NOT called when disposed", () => {
             const $state = state(1);
             const $derivation = derivation((get) => get($state) * 2);
@@ -402,8 +426,8 @@ describe("effect", () => {
                 resourceCounter++;
                 return resourceCounter;
             };
-            const $resource = resource(fetchResource, 0);
-            const $derivation = derivation((get) => get($resource) * 2);
+            const $resource = resource(fetchResource);
+            const $derivation = derivation((get) => (get($resource) ?? 0) * 2);
             const effectFn = vi.fn();
             effect((get) => effectFn(get($derivation)));
 

package/test/effect.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, signal } from "#package";
+
+describe("effect", () => {
+    test("disposed is correct", () => {
+        const $signal = signal();
+        const effectFn = vi.fn();
+        const $effect = effect((_, watch) => {
+            watch($signal);
+            effectFn();
+        });
+
+        expect($effect.disposed).toBe(false);
+        $effect.dispose();
+        expect($effect.disposed).toBe(true);
+    });
+
+    test("throw when disposed twice", () => {
+        const $signal = signal();
+        const effectFn = vi.fn();
+        const $effect = effect((_, watch) => {
+            watch($signal);
+            effectFn();
+        });
+
+        $effect.dispose();
+        expect(() => $effect.dispose()).toThrow("Effect is disposed");
+    });
+});

package/test/map.test.ts

@@ -2,6 +2,20 @@ import { describe, expect, test, vi } from "vitest";
 import { effect, map } from "#package";
 
 describe("map", () => {
+    test("is initialized", () => {
+        const $map = map({
+            key1: 1,
+            key2: 2,
+            key3: 3,
+        });
+
+        expect(Array.from($map.get().entries())).toEqual([
+            ["key1", 1],
+            ["key2", 2],
+            ["key3", 3],
+        ]);
+    });
+
     test("is updated", () => {
         const $map = map();
 
@@ -26,6 +40,30 @@ describe("map", () => {
         expect($map.get().get("key2")).toBe(2);
         expect($map.$lastDeleted.get()).toEqual({ key: "key1", value: 3 });
     });
+
+    test("get throws when disposed", () => {
+        const $map = map({ key1: 1, key2: 2, key3: 3 });
+        $map.dispose();
+        expect(() => $map.get()).toThrowError(
+            "[PicoFlow] Primitive is disposed",
+        );
+    });
+
+    test("set throws when disposed", () => {
+        const $map = map<string, number>();
+        $map.dispose();
+        expect(() => $map.setAt("key1", 2)).toThrowError(
+            "[PicoFlow] Primitive is disposed",
+        );
+    });
+
+    test("delete throws when disposed", () => {
+        const $map = map<string, number>({ key1: 1, key2: 2, key3: 3 });
+        $map.dispose();
+        expect(() => $map.delete("key1")).toThrowError(
+            "[PicoFlow] Primitive is disposed",
+        );
+    });
 });
 
 describe("effect", () => {

package/test/resource.test.ts

@@ -9,8 +9,8 @@ describe("resource", () => {
             return resourceCounter;
         };
 
-        const $resource = resource(fetchResource, 0);
-        expect($resource.get()).toBe(0);
+        const $resource = resource(fetchResource);
+        expect($resource.get()).toBe(undefined);
 
         await $resource.fetch();
         expect($resource.get()).toBe(1);
@@ -26,15 +26,15 @@ describe("resource", () => {
             return resourceCounter;
         };
 
-        const $resource = resource(fetchResource, 0);
-        expect($resource.get()).toBe(0);
+        const $resource = resource(fetchResource);
+        expect($resource.get()).toBe(undefined);
 
         await $resource.fetch();
         expect($resource.get()).toBe(1);
 
         $resource.dispose();
         await expect(() => $resource.fetch()).rejects.toThrow(
-            "Resource is disposed",
+            "[PicoFlow] Primitive is disposed",
         );
     });
 
@@ -45,14 +45,16 @@ describe("resource", () => {
             return resourceCounter;
         };
 
-        const $resource = resource(fetchResource, 0);
-        expect($resource.get()).toBe(0);
+        const $resource = resource(fetchResource);
+        expect($resource.get()).toBe(undefined);
 
         await $resource.fetch();
         expect($resource.get()).toBe(1);
 
         $resource.dispose();
-        expect(() => $resource.get()).toThrow("Resource is disposed");
+        expect(() => $resource.get()).toThrow(
+            "[PicoFlow] Primitive is disposed",
+        );
     });
 });
 
@@ -64,12 +66,12 @@ describe("effect", () => {
             return resourceCounter;
         };
 
-        const $resource = resource(fetchResource, 0);
+        const $resource = resource(fetchResource);
         const effectFn = vi.fn();
         effect((get) => effectFn(get($resource)));
 
         expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
 
         await $resource.fetch();
         expect(effectFn).toHaveBeenCalledTimes(2);
@@ -85,19 +87,19 @@ describe("effect", () => {
             return 0;
         };
 
-        const $resource = resource(fetchResource, 0);
+        const $resource = resource(fetchResource);
         const effectFn = vi.fn();
         effect((get) => effectFn(get($resource)));
 
         expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
 
         await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenCalledTimes(2);
         expect(effectFn).toHaveBeenLastCalledWith(0);
 
         await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenCalledTimes(2);
         expect(effectFn).toHaveBeenLastCalledWith(0);
     });
 
@@ -108,12 +110,12 @@ describe("effect", () => {
             return resourceCounter;
         };
 
-        const $resource = resource(fetchResource, 0);
+        const $resource = resource(fetchResource);
         const effectFn = vi.fn();
         const $effect = effect((get) => effectFn(get($resource)));
 
         expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
 
         await $resource.fetch();
         expect(effectFn).toHaveBeenCalledTimes(2);

package/test/resourceAsync.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, resourceAsync } from "#package";
+
+describe("resourceAsync", () => {
+    test("is updated", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resourceAsync(fetchResource);
+        expect(await $resource.get()).toBe(1);
+
+        $resource.fetch();
+        expect(await $resource.get()).toBe(2);
+
+        $resource.fetch();
+        expect(await $resource.get()).toBe(3);
+    });
+
+    test("fetch throws when disposed", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resourceAsync(fetchResource);
+        expect(await $resource.get()).toBe(1);
+
+        $resource.fetch();
+        expect(await $resource.get()).toBe(2);
+
+        $resource.dispose();
+        await expect(() => $resource.fetch()).rejects.toThrow(
+            "[PicoFlow] Primitive is disposed",
+        );
+    });
+
+    test("get throws when disposed", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resourceAsync(fetchResource);
+        expect(await $resource.get()).toBe(1);
+
+        $resource.fetch();
+        expect(await $resource.get()).toBe(2);
+
+        $resource.dispose();
+        expect(() => $resource.get()).toThrow(
+            "[PicoFlow] Primitive is disposed",
+        );
+    });
+});
+
+describe("effect", () => {
+    test("called when resource updated", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resourceAsync(fetchResource);
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($resource)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(await effectFn.mock.calls[0][0]).toBe(1);
+
+        $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toBe(2);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(await effectFn.mock.calls[2][0]).toBe(3);
+    });
+
+    test("NOT called when disposed", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resourceAsync(fetchResource);
+        const effectFn = vi.fn();
+        const $effect = effect((get) => effectFn(get($resource)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(await effectFn.mock.calls[0][0]).toBe(1);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toBe(2);
+
+        $effect.dispose();
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toBe(2);
+    });
+});

package/test/signal.test.ts

@@ -2,6 +2,13 @@ import { describe, expect, test, vi } from "vitest";
 import { effect, signal } from "#package";
 
 describe("signal", () => {
+    test("disposed is correct", () => {
+        const $signal = signal();
+        expect($signal.disposed).toBe(false);
+        $signal.dispose();
+        expect($signal.disposed).toBe(true);
+    });
+
     test("throws when disposed", () => {
         const $signal = signal();
         const effectFn = vi.fn();
@@ -16,7 +23,17 @@ describe("signal", () => {
         expect(effectFn).toHaveBeenCalledTimes(2);
 
         $signal.dispose();
-        expect(() => $signal.trigger()).toThrow("Signal is disposed");
+        expect(() => $signal.trigger()).toThrow(
+            "[PicoFlow] Primitive is disposed",
+        );
+    });
+
+    test("throws when disposed twice", () => {
+        const $signal = signal();
+        $signal.dispose();
+        expect(() => $signal.dispose()).toThrow(
+            "[PicoFlow] Primitive is disposed",
+        );
     });
 });
 

package/test/state.test.ts

@@ -2,6 +2,16 @@ import { describe, expect, test, vi } from "vitest";
 import { effect, state } from "#package";
 
 describe("state", () => {
+    test("is initialized", () => {
+        const $state = state(1);
+        expect($state.get()).toBe(1);
+    });
+
+    test("is lazy initialized", () => {
+        const $state = state(() => 1);
+        expect($state.get()).toBe(1);
+    });
+
     test("is updated", () => {
         const $state = state(1);
         expect($state.get()).toBe(1);
@@ -10,6 +20,14 @@ describe("state", () => {
         expect($state.get()).toBe(2);
     });
 
+    test("is updated from current", () => {
+        const $state = state(1);
+        expect($state.get()).toBe(1);
+
+        $state.set((state) => state + 1);
+        expect($state.get()).toBe(2);
+    });
+
     test("set throws when disposed", () => {
         const $state = state(1);
 
@@ -20,7 +38,7 @@ describe("state", () => {
 
         $state.dispose();
 
-        expect(() => $state.set(3)).toThrow("State is disposed");
+        expect(() => $state.set(3)).toThrow("[PicoFlow] Primitive is disposed");
     });
 
     test("get throws when disposed", () => {
@@ -33,11 +51,29 @@ describe("state", () => {
 
         $state.dispose();
 
-        expect(() => $state.get()).toThrow("State is disposed");
+        expect(() => $state.get()).toThrow("[PicoFlow] Primitive is disposed");
     });
 });
 
 describe("effect", () => {
+    test("called with init value", () => {
+        const $state = state(1);
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($state)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+    });
+
+    test("called with lazy init value", () => {
+        const $state = state(() => 1);
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($state)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+    });
+
     test("called when updated", () => {
         const $state = state(1);
         const effectFn = vi.fn();
@@ -87,3 +123,72 @@ describe("effect", () => {
         expect(effectFn).toHaveBeenLastCalledWith(2);
     });
 });
+
+describe("subscribe", () => {
+    test("called with init value", () => {
+        const $state = state(1);
+        const effectFn = vi.fn();
+        $state.subscribe((value) => effectFn(value));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+    });
+
+    test("called with lazy init value", () => {
+        const $state = state(() => 1);
+        const effectFn = vi.fn();
+        $state.subscribe((value) => effectFn(value));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+    });
+
+    test("called when updated", () => {
+        const $state = state(1);
+        const effectFn = vi.fn();
+        $state.subscribe((value) => effectFn(value));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        $state.set(2);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+
+    test("NOT called when updated with the same value", () => {
+        const $state = state(1);
+        const effectFn = vi.fn();
+        $state.subscribe((value) => effectFn(value));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        $state.set(2);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+
+        $state.set(2);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+
+    test("NOT called when disposed", () => {
+        const $state = state(1);
+        const effectFn = vi.fn();
+        const unsubscribe = $state.subscribe((value) => effectFn(value));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        $state.set(2);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+
+        unsubscribe();
+
+        $state.set(3);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+});

package/test/stream.test.ts

@@ -19,9 +19,9 @@ describe("stream", () => {
             return () => {
                 counter.callback = undefined;
             };
-        }, counter.count);
+        });
 
-        expect($stream.get()).toBe(0);
+        expect($stream.get()).toBe(undefined);
 
         counter.increment();
         expect($stream.get()).toBe(1);
@@ -40,9 +40,9 @@ describe("stream", () => {
                 set(counter);
             }, 1000);
             return () => clearInterval(interval);
-        }, 0);
+        });
 
-        expect($stream.get()).toBe(0);
+        expect($stream.get()).toBe(undefined);
 
         vi.advanceTimersToNextTimer();
         expect($stream.get()).toBe(1);
@@ -61,9 +61,9 @@ describe("stream", () => {
                 set(counter);
             }, 1000);
             return () => clearInterval(interval);
-        }, 0);
+        });
 
-        expect($stream.get()).toBe(0);
+        expect($stream.get()).toBe(undefined);
 
         vi.advanceTimersToNextTimer();
         expect($stream.get()).toBe(1);
@@ -73,7 +73,7 @@ describe("stream", () => {
 
         $stream.dispose();
         vi.advanceTimersToNextTimer();
-        expect(() => $stream.get()).toThrow("Stream is disposed");
+        expect(() => $stream.get()).toThrow("[PicoFlow] Primitive is disposed");
     });
 });
 
@@ -88,13 +88,13 @@ describe("effect", () => {
                 set(counter);
             }, 1000);
             return () => clearInterval(interval);
-        }, 0);
+        });
 
         const effectFn = vi.fn();
         effect((get) => effectFn(get($stream)));
 
         expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
 
         vi.advanceTimersToNextTimer();
         expect(effectFn).toHaveBeenCalledTimes(2);
@@ -105,6 +105,31 @@ describe("effect", () => {
         expect(effectFn).toHaveBeenLastCalledWith(2);
     });
 
+    test("NOT called when stream is updated with same value", async () => {
+        vi.useFakeTimers();
+
+        const $stream = stream((set) => {
+            const interval = setInterval(() => {
+                set(5);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($stream)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(5);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(5);
+    });
+
     test("NOT called when  disposed", async () => {
         vi.useFakeTimers();
 
@@ -115,13 +140,13 @@ describe("effect", () => {
                 set(counter);
             }, 1000);
             return () => clearInterval(interval);
-        }, 0);
+        });
 
         const effectFn = vi.fn();
         const $effect = effect((get) => effectFn(get($stream)));
 
         expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
 
         vi.advanceTimersToNextTimer();
         expect(effectFn).toHaveBeenCalledTimes(2);
@@ -147,13 +172,13 @@ describe("effect", () => {
                 set(counter);
             }, 1000);
             return () => clearInterval(interval);
-        }, 0);
+        });
 
         const effectFn = vi.fn();
         effect((get) => effectFn(get($stream)));
 
         expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
+        expect(effectFn).toHaveBeenLastCalledWith(undefined);
 
         vi.advanceTimersToNextTimer();
         expect(effectFn).toHaveBeenCalledTimes(2);