@ersbeth/picoflow 0.0.1

package/test/signal.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, signal } from "#package";
+
+describe("signal", () => {
+    test("throws when disposed", () => {
+        const $signal = signal();
+        const effectFn = vi.fn();
+        effect((_, watch) => {
+            watch($signal);
+            effectFn();
+        });
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+
+        $signal.trigger();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+
+        $signal.dispose();
+        expect(() => $signal.trigger()).toThrow("Signal is disposed");
+    });
+});
+
+describe("effect", () => {
+    test("called when signal triggered", () => {
+        const $signal = signal();
+        const effectFn = vi.fn();
+        effect((_, watch) => {
+            watch($signal);
+            effectFn();
+        });
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+
+        $signal.trigger();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+
+        $signal.trigger();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+    });
+
+    test("NOT called when disposed", () => {
+        const $signal = signal();
+        const effectFn = vi.fn();
+        const $effect = effect((_, watch) => {
+            watch($signal);
+            effectFn();
+        });
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+
+        $signal.trigger();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+
+        $effect.dispose();
+
+        $signal.trigger();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+    });
+});

package/test/state.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, state } from "#package";
+
+describe("state", () => {
+    test("is updated", () => {
+        const $state = state(1);
+        expect($state.get()).toBe(1);
+
+        $state.set(2);
+        expect($state.get()).toBe(2);
+    });
+
+    test("set throws when disposed", () => {
+        const $state = state(1);
+
+        expect($state.get()).toBe(1);
+
+        $state.set(2);
+        expect($state.get()).toBe(2);
+
+        $state.dispose();
+
+        expect(() => $state.set(3)).toThrow("State is disposed");
+    });
+
+    test("get throws when disposed", () => {
+        const $state = state(1);
+
+        expect($state.get()).toBe(1);
+
+        $state.set(2);
+        expect($state.get()).toBe(2);
+
+        $state.dispose();
+
+        expect(() => $state.get()).toThrow("State is disposed");
+    });
+});
+
+describe("effect", () => {
+    test("called when updated", () => {
+        const $state = state(1);
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($state)));
+
+        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();
+        effect((get) => effectFn(get($state)));
+
+        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 $effect = effect((get) => effectFn(get($state)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        $state.set(2);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+
+        $effect.dispose();
+
+        $state.set(3);
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+});

package/test/stream.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, test, vi } from "vitest";
+import { stream, effect } from "#package";
+
+describe("stream", () => {
+    test("is updated (callback)", async () => {
+        const counter = {
+            count: 0,
+            callback: undefined as ((value: number) => void) | undefined,
+            increment() {
+                this.count++;
+                if (this.callback) {
+                    this.callback(this.count);
+                }
+            },
+        };
+
+        const $stream = stream((set) => {
+            counter.callback = set;
+            return () => {
+                counter.callback = undefined;
+            };
+        }, counter.count);
+
+        expect($stream.get()).toBe(0);
+
+        counter.increment();
+        expect($stream.get()).toBe(1);
+
+        counter.increment();
+        expect($stream.get()).toBe(2);
+    });
+
+    test("stream is updated (interval)", async () => {
+        vi.useFakeTimers();
+
+        const $stream = stream((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        }, 0);
+
+        expect($stream.get()).toBe(0);
+
+        vi.advanceTimersToNextTimer();
+        expect($stream.get()).toBe(1);
+
+        vi.advanceTimersToNextTimer();
+        expect($stream.get()).toBe(2);
+    });
+
+    test("get throws when stream is disposed", async () => {
+        vi.useFakeTimers();
+
+        const $stream = stream((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        }, 0);
+
+        expect($stream.get()).toBe(0);
+
+        vi.advanceTimersToNextTimer();
+        expect($stream.get()).toBe(1);
+
+        vi.advanceTimersToNextTimer();
+        expect($stream.get()).toBe(2);
+
+        $stream.dispose();
+        vi.advanceTimersToNextTimer();
+        expect(() => $stream.get()).toThrow("Stream is disposed");
+    });
+});
+
+describe("effect", () => {
+    test("called when stream is updated", async () => {
+        vi.useFakeTimers();
+
+        const $stream = stream((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        }, 0);
+
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($stream)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+
+    test("NOT called when  disposed", async () => {
+        vi.useFakeTimers();
+
+        const $stream = stream((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                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);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+
+        $effect.dispose();
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+
+    test("NOT called when stream is disposed", async () => {
+        vi.useFakeTimers();
+
+        const $stream = stream((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        }, 0);
+
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($stream)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+
+        $stream.dispose();
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "rootDir": ".",
+        "target": "ESNext",
+
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+
+        "declaration": true,
+        "declarationMap": true,
+        "outDir": "dist/types",
+
+        "strict": true,
+        "verbatimModuleSyntax": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitOverride": true,
+        "noImplicitReturns": true
+    },
+    "include": ["./src/**/*", "./test/**/*"]
+}

package/vite.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+
+export default defineConfig({
+    root: "./src",
+    build: {
+        outDir: "../dist",
+        emptyOutDir: true,
+        lib: {
+            entry: "index.ts",
+            formats: ["es"],
+        },
+        target: "esnext",
+        minify: false,
+    },
+
+    plugins: [
+        dts({
+            include: "**/*",
+            outDir: "../dist/types",
+            compilerOptions: {
+                rootDir: "src",
+            },
+        }),
+    ],
+});

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        include: ["**/*.test.ts"],
+        coverage: {
+            reporter: ["text"],
+            include: ["src/**/*"],
+        },
+    },
+});