@ersbeth/picoflow 0.2.4 → 1.0.1

package/test/resource.test.ts

@@ -2,128 +2,126 @@ import { describe, expect, test, vi } from "vitest";
 import { effect, resource } from "#package";
 
 describe("resource", () => {
-    test("is updated", async () => {
-        let resourceCounter = 0;
-        const fetchResource = async () => {
-            resourceCounter++;
-            return resourceCounter;
-        };
-
-        const $resource = resource(fetchResource);
-        expect($resource.get()).toBe(undefined);
-
-        await $resource.fetch();
-        expect($resource.get()).toBe(1);
-
-        await $resource.fetch();
-        expect($resource.get()).toBe(2);
-    });
-
-    test("fetch throws when disposed", async () => {
-        let resourceCounter = 0;
-        const fetchResource = async () => {
-            resourceCounter++;
-            return resourceCounter;
-        };
-
-        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(
-            "[PicoFlow] Primitive is disposed",
-        );
-    });
-
-    test("get throws when disposed", async () => {
-        let resourceCounter = 0;
-        const fetchResource = async () => {
-            resourceCounter++;
-            return resourceCounter;
-        };
-
-        const $resource = resource(fetchResource);
-        expect($resource.get()).toBe(undefined);
-
-        await $resource.fetch();
-        expect($resource.get()).toBe(1);
-
-        $resource.dispose();
-        expect(() => $resource.get()).toThrow(
-            "[PicoFlow] Primitive is disposed",
-        );
-    });
+	test("is updated", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resource(fetchResource);
+		expect($resource.pick()).toBe(undefined);
+
+		await $resource.fetch();
+		expect($resource.pick()).toBe(1);
+
+		await $resource.fetch();
+		expect($resource.pick()).toBe(2);
+	});
+
+	test("fetch throws when disposed", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resource(fetchResource);
+		expect($resource.pick()).toBe(undefined);
+
+		await $resource.fetch();
+		expect($resource.pick()).toBe(1);
+
+		$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 = resource(fetchResource);
+		expect($resource.pick()).toBe(undefined);
+
+		await $resource.fetch();
+		expect($resource.pick()).toBe(1);
+
+		$resource.dispose();
+		expect(() => $resource.pick()).toThrow("[PicoFlow] Primitive is disposed");
+	});
 });
 
 describe("effect", () => {
-    test("called when resource updated", async () => {
-        let resourceCounter = 0;
-        const fetchResource = async () => {
-            resourceCounter++;
-            return resourceCounter;
-        };
-
-        const $resource = resource(fetchResource);
-        const effectFn = vi.fn();
-        effect((get) => effectFn(get($resource)));
-
-        expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(undefined);
-
-        await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(2);
-        expect(effectFn).toHaveBeenLastCalledWith(1);
-
-        await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(3);
-        expect(effectFn).toHaveBeenLastCalledWith(2);
-    });
-
-    test("NOT updated when value don't change", async () => {
-        const fetchResource = async () => {
-            return 0;
-        };
-
-        const $resource = resource(fetchResource);
-        const effectFn = vi.fn();
-        effect((get) => effectFn(get($resource)));
-
-        expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(undefined);
-
-        await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(2);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
-
-        await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(2);
-        expect(effectFn).toHaveBeenLastCalledWith(0);
-    });
-
-    test("NOT called when disposed", async () => {
-        let resourceCounter = 0;
-        const fetchResource = async () => {
-            resourceCounter++;
-            return resourceCounter;
-        };
-
-        const $resource = resource(fetchResource);
-        const effectFn = vi.fn();
-        const $effect = effect((get) => effectFn(get($resource)));
-
-        expect(effectFn).toHaveBeenCalledTimes(1);
-        expect(effectFn).toHaveBeenLastCalledWith(undefined);
-
-        await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(2);
-        expect(effectFn).toHaveBeenLastCalledWith(1);
-
-        $effect.dispose();
-        await $resource.fetch();
-        expect(effectFn).toHaveBeenCalledTimes(2);
-        expect(effectFn).toHaveBeenLastCalledWith(1);
-    });
+	test("called when resource updated", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resource(fetchResource);
+		const effectFn = vi.fn();
+		effect((t) => effectFn($resource.get(t)));
+
+		expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+		await $resource.fetch();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+		expect(effectFn).toHaveBeenLastCalledWith(1);
+
+		await $resource.fetch();
+		expect(effectFn).toHaveBeenCalledTimes(3);
+		expect(effectFn).toHaveBeenLastCalledWith(2);
+	});
+
+	test("NOT updated when value don't change", async () => {
+		const fetchResource = async () => {
+			return 0;
+		};
+
+		const $resource = resource(fetchResource);
+		const effectFn = vi.fn();
+		effect((t) => effectFn($resource.get(t)));
+
+		expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+		await $resource.fetch();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+		expect(effectFn).toHaveBeenLastCalledWith(0);
+
+		await $resource.fetch();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+		expect(effectFn).toHaveBeenLastCalledWith(0);
+	});
+
+	test("NOT called when disposed", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resource(fetchResource);
+		const effectFn = vi.fn();
+		const $effect = effect((t) => effectFn($resource.get(t)));
+
+		expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenLastCalledWith(undefined);
+
+		await $resource.fetch();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+		expect(effectFn).toHaveBeenLastCalledWith(1);
+
+		$effect.dispose();
+		await $resource.fetch();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+		expect(effectFn).toHaveBeenLastCalledWith(1);
+	});
 });

package/test/resourceAsync.test.ts

@@ -2,107 +2,105 @@ 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",
-        );
-    });
+	test("is updated", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resourceAsync(fetchResource);
+		expect(await $resource.pick()).toBe(1);
+
+		$resource.fetch();
+		expect(await $resource.pick()).toBe(2);
+
+		$resource.fetch();
+		expect(await $resource.pick()).toBe(3);
+	});
+
+	test("fetch throws when disposed", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resourceAsync(fetchResource);
+		expect(await $resource.pick()).toBe(1);
+
+		$resource.fetch();
+		expect(await $resource.pick()).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.pick()).toBe(1);
+
+		$resource.fetch();
+		expect(await $resource.pick()).toBe(2);
+
+		$resource.dispose();
+		expect(() => $resource.pick()).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);
-    });
+	test("called when resource updated", async () => {
+		let resourceCounter = 0;
+		const fetchResource = async () => {
+			resourceCounter++;
+			return resourceCounter;
+		};
+
+		const $resource = resourceAsync(fetchResource);
+		const effectFn = vi.fn();
+		effect((t) => effectFn($resource.get(t)));
+
+		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((t) => effectFn($resource.get(t)));
+
+		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,75 +2,71 @@ 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("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();
-        effect((_, watch) => {
-            watch($signal);
-            effectFn();
-        });
+	test("throws when disposed", () => {
+		const $signal = signal();
+		const effectFn = vi.fn();
+		effect((t) => {
+			$signal.watch(t);
+			effectFn();
+		});
 
-        expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenCalledTimes(1);
 
-        $signal.trigger();
-        expect(effectFn).toHaveBeenCalledTimes(2);
+		$signal.trigger();
+		expect(effectFn).toHaveBeenCalledTimes(2);
 
-        $signal.dispose();
-        expect(() => $signal.trigger()).toThrow(
-            "[PicoFlow] Primitive is disposed",
-        );
-    });
+		$signal.dispose();
+		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",
-        );
-    });
+	test("throws when disposed twice", () => {
+		const $signal = signal();
+		$signal.dispose();
+		expect(() => $signal.dispose()).toThrow("[PicoFlow] Primitive is disposed");
+	});
 });
 
 describe("effect", () => {
-    test("called when signal triggered", () => {
-        const $signal = signal();
-        const effectFn = vi.fn();
-        effect((_, watch) => {
-            watch($signal);
-            effectFn();
-        });
+	test("called when signal triggered", () => {
+		const $signal = signal();
+		const effectFn = vi.fn();
+		effect((t) => {
+			$signal.watch(t);
+			effectFn();
+		});
 
-        expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenCalledTimes(1);
 
-        $signal.trigger();
-        expect(effectFn).toHaveBeenCalledTimes(2);
+		$signal.trigger();
+		expect(effectFn).toHaveBeenCalledTimes(2);
 
-        $signal.trigger();
-        expect(effectFn).toHaveBeenCalledTimes(3);
-    });
+		$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();
-        });
+	test("NOT called when disposed", () => {
+		const $signal = signal();
+		const effectFn = vi.fn();
+		const $effect = effect((t) => {
+			$signal.watch(t);
+			effectFn();
+		});
 
-        expect(effectFn).toHaveBeenCalledTimes(1);
+		expect(effectFn).toHaveBeenCalledTimes(1);
 
-        $signal.trigger();
-        expect(effectFn).toHaveBeenCalledTimes(2);
+		$signal.trigger();
+		expect(effectFn).toHaveBeenCalledTimes(2);
 
-        $effect.dispose();
+		$effect.dispose();
 
-        $signal.trigger();
-        expect(effectFn).toHaveBeenCalledTimes(2);
-    });
+		$signal.trigger();
+		expect(effectFn).toHaveBeenCalledTimes(2);
+	});
 });