@ersbeth/picoflow 0.2.4 → 1.0.0

package/test/stream.test.ts

@@ -1,196 +1,196 @@
 import { describe, expect, test, vi } from "vitest";
-import { stream, effect } from "#package";
+import { effect, stream } 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;
-            };
-        });
-
-        expect($stream.get()).toBe(undefined);
-
-        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);
-        });
-
-        expect($stream.get()).toBe(undefined);
-
-        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);
-        });
-
-        expect($stream.get()).toBe(undefined);
-
-        vi.advanceTimersToNextTimer();
-        expect($stream.get()).toBe(1);
-
-        vi.advanceTimersToNextTimer();
-        expect($stream.get()).toBe(2);
-
-        $stream.dispose();
-        vi.advanceTimersToNextTimer();
-        expect(() => $stream.get()).toThrow("[PicoFlow] Primitive is disposed");
-    });
+	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;
+			};
+		});
+
+		expect($stream.pick()).toBe(undefined);
+
+		counter.increment();
+		expect($stream.pick()).toBe(1);
+
+		counter.increment();
+		expect($stream.pick()).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);
+		});
+
+		expect($stream.pick()).toBe(undefined);
+
+		vi.advanceTimersToNextTimer();
+		expect($stream.pick()).toBe(1);
+
+		vi.advanceTimersToNextTimer();
+		expect($stream.pick()).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);
+		});
+
+		expect($stream.pick()).toBe(undefined);
+
+		vi.advanceTimersToNextTimer();
+		expect($stream.pick()).toBe(1);
+
+		vi.advanceTimersToNextTimer();
+		expect($stream.pick()).toBe(2);
+
+		$stream.dispose();
+		vi.advanceTimersToNextTimer();
+		expect(() => $stream.pick()).toThrow("[PicoFlow] Primitive 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);
-        });
-
-        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(1);
-
-        vi.advanceTimersToNextTimer();
-        expect(effectFn).toHaveBeenCalledTimes(3);
-        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();
-
-        const $stream = stream((set) => {
-            let counter = 0;
-            const interval = setInterval(() => {
-                counter++;
-                set(counter);
-            }, 1000);
-            return () => clearInterval(interval);
-        });
-
-        const effectFn = vi.fn();
-        const $effect = effect((get) => effectFn(get($stream)));
-
-        expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(undefined);
-
-        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);
-        });
-
-        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(1);
-
-        vi.advanceTimersToNextTimer();
-        expect(effectFn).toHaveBeenCalledTimes(3);
-        expect(effectFn).toHaveBeenLastCalledWith(2);
-
-        $stream.dispose();
-        vi.advanceTimersToNextTimer();
-        expect(effectFn).toHaveBeenCalledTimes(3);
-        expect(effectFn).toHaveBeenLastCalledWith(2);
-    });
+	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);
+		});
+
+		const effectFn = vi.fn();
+		effect((t) => effectFn($stream.get(t)));
+
+		expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+		vi.advanceTimersToNextTimer();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+		expect(effectFn).toHaveBeenLastCalledWith(1);
+
+		vi.advanceTimersToNextTimer();
+		expect(effectFn).toHaveBeenCalledTimes(3);
+		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((t) => effectFn($stream.get(t)));
+
+		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();
+
+		const $stream = stream((set) => {
+			let counter = 0;
+			const interval = setInterval(() => {
+				counter++;
+				set(counter);
+			}, 1000);
+			return () => clearInterval(interval);
+		});
+
+		const effectFn = vi.fn();
+		const $effect = effect((t) => effectFn($stream.get(t)));
+
+		expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+		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);
+		});
+
+		const effectFn = vi.fn();
+		effect((t) => effectFn($stream.get(t)));
+
+		expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+		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);
+	});
 });