@ersbeth/picoflow 1.0.1 → 1.1.0

package/test/map.test.ts

@@ -1,240 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import { effect, type FlowState, map, state } from "#package";
-
-describe("map", () => {
-	test("is initialized", () => {
-		const $map = map({
-			key1: 1,
-			key2: 2,
-			key3: 3,
-		});
-
-		expect(Array.from($map.pick().entries())).toEqual([
-			["key1", 1],
-			["key2", 2],
-			["key3", 3],
-		]);
-	});
-
-	test("is updated", () => {
-		const $map = map();
-
-		expect(Array.from($map.pick().entries())).toEqual([]);
-
-		$map.add("key1", 1);
-		expect($map.pick().get("key1")).toBe(1);
-		expect($map.$lastAdded.pick()).toEqual({ key: "key1", value: 1 });
-
-		$map.add("key2", 2);
-		expect($map.pick().get("key1")).toBe(1);
-		expect($map.pick().get("key2")).toBe(2);
-		expect($map.$lastAdded.pick()).toEqual({ key: "key2", value: 2 });
-
-		$map.update("key1", 3);
-		expect($map.pick().get("key1")).toBe(3);
-		expect($map.pick().get("key2")).toBe(2);
-		expect($map.$lastUpdated.pick()).toEqual({ key: "key1", value: 3 });
-
-		$map.delete("key1");
-		expect($map.pick().get("key1")).toBe(undefined);
-		expect($map.pick().get("key2")).toBe(2);
-		expect($map.$lastDeleted.pick()).toEqual({ key: "key1", value: 3 });
-	});
-
-	test("get throws when disposed", () => {
-		const $map = map({ key1: 1, key2: 2, key3: 3 });
-		$map.dispose();
-		expect(() => $map.pick()).toThrowError("[PicoFlow] Primitive is disposed");
-	});
-
-	test("add throws when disposed", () => {
-		const $map = map<string, number>();
-		$map.dispose();
-		expect(() => $map.add("key1", 2)).toThrowError(
-			"[PicoFlow] Primitive is disposed",
-		);
-	});
-
-	test("update throws when disposed", () => {
-		const $map = map<string, number>();
-		$map.add("key1", 1);
-		$map.dispose();
-		expect(() => $map.update("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",
-		);
-	});
-
-	test("add throws when key already exists", () => {
-		const $map = map<string, number>();
-		$map.add("key1", 1);
-		expect(() => $map.add("key1", 2)).toThrowError(
-			"[PicoFlow] Key already exists",
-		);
-	});
-
-	test("update throws when key does not exist", () => {
-		const $map = map<string, number>();
-		expect(() => $map.update("key1", 1)).toThrowError(
-			"[PicoFlow] Key does not exist",
-		);
-	});
-
-	test("dispose disposes map values that are disposable", () => {
-		const $map = map<string, FlowState<number>>();
-		const $value1 = state(1);
-		const $value2 = state(2);
-		const $value3 = state(3);
-
-		$map.add("key1", $value1);
-		$map.add("key2", $value2);
-		$map.add("key3", $value3);
-
-		expect($value1.disposed).toBe(false);
-		expect($value2.disposed).toBe(false);
-		expect($value3.disposed).toBe(false);
-
-		$map.dispose();
-
-		expect($value1.disposed).toBe(true);
-		expect($value2.disposed).toBe(true);
-		expect($value3.disposed).toBe(true);
-	});
-
-	test("dispose clears the map after disposing values", () => {
-		const $map = map<string, FlowState<number>>();
-		const $value1 = state(1);
-		const $value2 = state(2);
-
-		$map.add("key1", $value1);
-		$map.add("key2", $value2);
-
-		expect($map.pick().size).toBe(2);
-
-		$map.dispose();
-
-		// Map is cleared during disposal, but we can't verify after disposal
-		// since pick() will throw. We verify the values were disposed instead.
-		expect($value1.disposed).toBe(true);
-		expect($value2.disposed).toBe(true);
-	});
-
-	test("dispose handles non-disposable values gracefully", () => {
-		const $map = map<string, number>();
-		$map.add("key1", 1);
-		$map.add("key2", 2);
-		$map.add("key3", 3);
-
-		expect($map.pick().size).toBe(3);
-
-		// Should not throw even with non-disposable values
-		expect(() => $map.dispose()).not.toThrow();
-	});
-
-	test("dispose passes options to value disposal", () => {
-		const $map = map<string, FlowState<number>>();
-		const $value1 = state(1);
-		const $value2 = state(2);
-
-		$map.add("key1", $value1);
-		$map.add("key2", $value2);
-
-		// Create an effect that depends on value1
-		const fx = effect((t) => {
-			$value1.get(t);
-		});
-
-		expect(fx.disposed).toBe(false);
-
-		// Dispose with self: true - should only dispose the map and values, not dependent effects
-		$map.dispose({ self: true });
-
-		expect($value1.disposed).toBe(true);
-		expect($value2.disposed).toBe(true);
-		// Effect should still be active since we used self: true
-		expect(fx.disposed).toBe(false);
-
-		fx.dispose();
-	});
-});
-
-describe("effect", () => {
-	test("called when map is updated", () => {
-		const $map = map();
-		const onSetFn = vi.fn();
-		const onAddFn = vi.fn();
-		const onUpdateFn = vi.fn();
-		const onDeleteFn = vi.fn();
-
-		effect((t) => onSetFn($map.get(t)));
-		effect((t) => onAddFn($map.$lastAdded.get(t)));
-		effect((t) => onUpdateFn($map.$lastUpdated.get(t)));
-		effect((t) => onDeleteFn($map.$lastDeleted.get(t)));
-
-		expect(onSetFn).toHaveBeenCalledTimes(1);
-		expect(onSetFn).toHaveBeenLastCalledWith(new Map());
-		expect(onAddFn).toHaveBeenCalledTimes(1);
-		expect(onAddFn).toHaveBeenLastCalledWith(null);
-		expect(onUpdateFn).toHaveBeenCalledTimes(1);
-		expect(onUpdateFn).toHaveBeenLastCalledWith(null);
-		expect(onDeleteFn).toHaveBeenCalledTimes(1);
-		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
-
-		$map.add("key1", 1);
-		expect(onSetFn).toHaveBeenCalledTimes(2);
-		expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key1", 1]]));
-		expect(onAddFn).toHaveBeenCalledTimes(2);
-		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key1", value: 1 });
-		expect(onUpdateFn).toHaveBeenCalledTimes(1);
-		expect(onUpdateFn).toHaveBeenLastCalledWith(null);
-		expect(onDeleteFn).toHaveBeenCalledTimes(1);
-		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
-
-		$map.add("key2", 2);
-		expect(onSetFn).toHaveBeenCalledTimes(3);
-		expect(onSetFn).toHaveBeenLastCalledWith(
-			new Map([
-				["key1", 1],
-				["key2", 2],
-			]),
-		);
-		expect(onAddFn).toHaveBeenCalledTimes(3);
-		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
-		expect(onUpdateFn).toHaveBeenCalledTimes(1);
-		expect(onUpdateFn).toHaveBeenLastCalledWith(null);
-		expect(onDeleteFn).toHaveBeenCalledTimes(1);
-		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
-
-		$map.update("key1", 3);
-		expect(onSetFn).toHaveBeenCalledTimes(4);
-		expect(onSetFn).toHaveBeenLastCalledWith(
-			new Map([
-				["key1", 3],
-				["key2", 2],
-			]),
-		);
-		expect(onAddFn).toHaveBeenCalledTimes(3);
-		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
-		expect(onUpdateFn).toHaveBeenCalledTimes(2);
-		expect(onUpdateFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
-		expect(onDeleteFn).toHaveBeenCalledTimes(1);
-		expect(onDeleteFn).toHaveBeenLastCalledWith(null);
-
-		$map.delete("key1");
-		expect(onSetFn).toHaveBeenCalledTimes(5);
-		expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key2", 2]]));
-		expect(onAddFn).toHaveBeenCalledTimes(3);
-		expect(onAddFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
-		expect(onUpdateFn).toHaveBeenCalledTimes(2);
-		expect(onUpdateFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
-		expect(onDeleteFn).toHaveBeenCalledTimes(2);
-		expect(onDeleteFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
-	});
-});

package/test/signal.test.ts

@@ -1,72 +0,0 @@
-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();
-		effect((t) => {
-			$signal.watch(t);
-			effectFn();
-		});
-
-		expect(effectFn).toHaveBeenCalledTimes(1);
-
-		$signal.trigger();
-		expect(effectFn).toHaveBeenCalledTimes(2);
-
-		$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");
-	});
-});
-
-describe("effect", () => {
-	test("called when signal triggered", () => {
-		const $signal = signal();
-		const effectFn = vi.fn();
-		effect((t) => {
-			$signal.watch(t);
-			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((t) => {
-			$signal.watch(t);
-			effectFn();
-		});
-
-		expect(effectFn).toHaveBeenCalledTimes(1);
-
-		$signal.trigger();
-		expect(effectFn).toHaveBeenCalledTimes(2);
-
-		$effect.dispose();
-
-		$signal.trigger();
-		expect(effectFn).toHaveBeenCalledTimes(2);
-	});
-});

package/test/state.test.ts

@@ -1,212 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import { effect, state } from "#package";
-
-describe("state", () => {
-	test("is initialized", () => {
-		const $state = state(1);
-		expect($state.pick()).toBe(1);
-	});
-
-	test("is lazy initialized", () => {
-		const $state = state(() => 1);
-		expect($state.pick()).toBe(1);
-	});
-
-	test("is updated", () => {
-		const $state = state(1);
-		expect($state.pick()).toBe(1);
-
-		$state.set(2);
-		expect($state.pick()).toBe(2);
-	});
-
-	test("is updated from current", () => {
-		const $state = state(1);
-		expect($state.pick()).toBe(1);
-
-		$state.set((state) => state + 1);
-		expect($state.pick()).toBe(2);
-	});
-
-	test("set throws when disposed", () => {
-		const $state = state(1);
-
-		expect($state.pick()).toBe(1);
-
-		$state.set(2);
-		expect($state.pick()).toBe(2);
-
-		$state.dispose();
-
-		expect(() => $state.set(3)).toThrow("[PicoFlow] Primitive is disposed");
-	});
-
-	test("get throws when disposed", () => {
-		const $state = state(1);
-
-		expect($state.pick()).toBe(1);
-
-		$state.set(2);
-		expect($state.pick()).toBe(2);
-
-		$state.dispose();
-
-		expect(() => $state.pick()).toThrow("[PicoFlow] Primitive is disposed");
-	});
-});
-
-describe("effect", () => {
-	test("called with init value", () => {
-		const $state = state(1);
-		const effectFn = vi.fn();
-		effect((t) => effectFn($state.get(t)));
-
-		expect(effectFn).toHaveBeenCalledTimes(1);
-		expect(effectFn).toHaveBeenLastCalledWith(1);
-	});
-
-	test("called with lazy init value", () => {
-		const $state = state(() => 1);
-		const effectFn = vi.fn();
-		effect((t) => effectFn($state.get(t)));
-
-		expect(effectFn).toHaveBeenCalledTimes(1);
-		expect(effectFn).toHaveBeenLastCalledWith(1);
-	});
-
-	test("called when updated", () => {
-		const $state = state(1);
-		const effectFn = vi.fn();
-		effect((t) => effectFn($state.get(t)));
-
-		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((t) => effectFn($state.get(t)));
-
-		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((t) => effectFn($state.get(t)));
-
-		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);
-	});
-
-	test("nested states", () => {
-		const $stateA = state(1);
-		const $stateB = state(2);
-		const $stateC = state({
-			a: $stateA,
-			b: $stateB,
-		});
-
-		const effectFn = vi.fn();
-		effect((t) => {
-			const a = $stateC.get(t).a.get(t);
-			effectFn(a);
-		});
-
-		expect(effectFn).toHaveBeenCalledTimes(1);
-		expect(effectFn).toHaveBeenLastCalledWith(1);
-	});
-});
-
-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);
-	});
-});