atomirx 0.0.2 → 0.0.5

package/src/core/atom.test.ts

@@ -6,7 +6,7 @@ describe("atom", () => {
   describe("basic functionality", () => {
     it("should create an atom with initial value", () => {
       const count$ = atom(0);
-      expect(count$.value).toBe(0);
+      expect(count$.get()).toBe(0);
     });
 
     it("should have SYMBOL_ATOM marker", () => {
@@ -17,51 +17,51 @@ describe("atom", () => {
     it("should set value directly", () => {
       const count$ = atom(0);
       count$.set(5);
-      expect(count$.value).toBe(5);
+      expect(count$.get()).toBe(5);
     });
 
     it("should set value with reducer", () => {
       const count$ = atom(0);
       count$.set((prev) => prev + 1);
-      expect(count$.value).toBe(1);
+      expect(count$.get()).toBe(1);
       count$.set((prev) => prev * 2);
-      expect(count$.value).toBe(2);
+      expect(count$.get()).toBe(2);
     });
 
     it("should reset to initial value", () => {
       const count$ = atom(10);
       count$.set(42);
-      expect(count$.value).toBe(42);
+      expect(count$.get()).toBe(42);
       count$.reset();
-      expect(count$.value).toBe(10);
+      expect(count$.get()).toBe(10);
     });
 
     it("should store objects", () => {
       const user$ = atom({ name: "John", age: 30 });
-      expect(user$.value).toEqual({ name: "John", age: 30 });
+      expect(user$.get()).toEqual({ name: "John", age: 30 });
       user$.set({ name: "Jane", age: 25 });
-      expect(user$.value).toEqual({ name: "Jane", age: 25 });
+      expect(user$.get()).toEqual({ name: "Jane", age: 25 });
     });
 
     it("should store null and undefined", () => {
       const nullable$ = atom<string | null>(null);
-      expect(nullable$.value).toBe(null);
+      expect(nullable$.get()).toBe(null);
       nullable$.set("hello");
-      expect(nullable$.value).toBe("hello");
+      expect(nullable$.get()).toBe("hello");
       nullable$.set(null);
-      expect(nullable$.value).toBe(null);
+      expect(nullable$.get()).toBe(null);
 
       const undef$ = atom<string | undefined>(undefined);
-      expect(undef$.value).toBe(undefined);
+      expect(undef$.get()).toBe(undefined);
       undef$.set("world");
-      expect(undef$.value).toBe("world");
+      expect(undef$.get()).toBe("world");
     });
 
     it("should store arrays", () => {
       const items$ = atom<number[]>([1, 2, 3]);
-      expect(items$.value).toEqual([1, 2, 3]);
+      expect(items$.get()).toEqual([1, 2, 3]);
       items$.set((prev) => [...prev, 4]);
-      expect(items$.value).toEqual([1, 2, 3, 4]);
+      expect(items$.get()).toEqual([1, 2, 3, 4]);
     });
   });
 
@@ -223,25 +223,25 @@ describe("atom", () => {
     it("should store Promise as-is", () => {
       const promise = Promise.resolve(42);
       const data$ = atom(promise);
-      expect(data$.value).toBe(promise);
+      expect(data$.get()).toBe(promise);
     });
 
     it("should store a new Promise on set", () => {
       const promise1 = Promise.resolve(1);
       const promise2 = Promise.resolve(2);
       const data$ = atom(promise1);
-      expect(data$.value).toBe(promise1);
+      expect(data$.get()).toBe(promise1);
       data$.set(promise2);
-      expect(data$.value).toBe(promise2);
+      expect(data$.get()).toBe(promise2);
     });
 
     it("should reset to original Promise object", () => {
       const originalPromise = Promise.resolve(42);
       const data$ = atom(originalPromise);
       data$.set(Promise.resolve(100));
-      expect(data$.value).not.toBe(originalPromise);
+      expect(data$.get()).not.toBe(originalPromise);
       data$.reset();
-      expect(data$.value).toBe(originalPromise);
+      expect(data$.get()).toBe(originalPromise);
     });
   });
 
@@ -255,7 +255,7 @@ describe("atom", () => {
         });
       }).toThrow(error);
       // Value should remain unchanged
-      expect(count$.value).toBe(0);
+      expect(count$.get()).toBe(0);
     });
   });
 
@@ -264,7 +264,7 @@ describe("atom", () => {
       const initializer = vi.fn(() => 42);
       const count$ = atom(initializer);
       expect(initializer).toHaveBeenCalledTimes(1);
-      expect(count$.value).toBe(42);
+      expect(count$.get()).toBe(42);
     });
 
     it("should only call initializer once", () => {
@@ -272,8 +272,8 @@ describe("atom", () => {
       const obj$ = atom(initializer);
       expect(initializer).toHaveBeenCalledTimes(1);
       // Access value multiple times
-      obj$.value;
-      obj$.value;
+      obj$.get();
+      obj$.get();
       expect(initializer).toHaveBeenCalledTimes(1);
     });
 
@@ -284,33 +284,33 @@ describe("atom", () => {
         return callCount; // Returns different value each call
       };
       const count$ = atom(initializer);
-      expect(count$.value).toBe(1); // First call returns 1
+      expect(count$.get()).toBe(1); // First call returns 1
       expect(callCount).toBe(1);
 
       count$.set(100);
-      expect(count$.value).toBe(100);
+      expect(count$.get()).toBe(100);
 
       count$.reset();
-      expect(count$.value).toBe(2); // Re-runs initializer, gets fresh value
+      expect(count$.get()).toBe(2); // Re-runs initializer, gets fresh value
       expect(callCount).toBe(2); // Initializer called again
     });
 
     it("should work with lazy initializer returning object", () => {
       const obj$ = atom(() => ({ count: 0, items: [] as number[] }));
-      expect(obj$.value).toEqual({ count: 0, items: [] });
+      expect(obj$.get()).toEqual({ count: 0, items: [] });
       obj$.set((prev) => ({ ...prev, count: 1 }));
-      expect(obj$.value).toEqual({ count: 1, items: [] });
+      expect(obj$.get()).toEqual({ count: 1, items: [] });
     });
 
     it("should work with lazy initializer returning Promise", () => {
       const promise = Promise.resolve(42);
       const data$ = atom(() => promise);
-      expect(data$.value).toBe(promise);
+      expect(data$.get()).toBe(promise);
     });
 
     it("should still work with direct value (non-function)", () => {
       const count$ = atom(10);
-      expect(count$.value).toBe(10);
+      expect(count$.get()).toBe(10);
     });
   });
 
@@ -326,44 +326,308 @@ describe("atom", () => {
     });
   });
 
+  describe("AtomContext (init function with context)", () => {
+    describe("signal", () => {
+      it("should pass context with signal to init function", () => {
+        let receivedSignal: AbortSignal | undefined;
+        atom((ctx) => {
+          receivedSignal = ctx.signal;
+          return 42;
+        });
+        expect(receivedSignal).toBeInstanceOf(AbortSignal);
+        expect(receivedSignal!.aborted).toBe(false);
+      });
+
+      it("should abort signal when set() is called", () => {
+        let receivedSignal: AbortSignal | undefined;
+        const count$ = atom((ctx) => {
+          receivedSignal = ctx.signal;
+          return 0;
+        });
+        expect(receivedSignal!.aborted).toBe(false);
+
+        count$.set(1);
+        expect(receivedSignal!.aborted).toBe(true);
+      });
+
+      it("should abort signal when reset() is called", () => {
+        const signals: AbortSignal[] = [];
+        const count$ = atom((ctx) => {
+          signals.push(ctx.signal);
+          return 0;
+        });
+        expect(signals[0].aborted).toBe(false);
+
+        count$.reset();
+        // Original signal should be aborted
+        expect(signals[0].aborted).toBe(true);
+      });
+
+      it("should provide fresh signal on reset", () => {
+        const signals: AbortSignal[] = [];
+        const count$ = atom((ctx) => {
+          signals.push(ctx.signal);
+          return signals.length;
+        });
+
+        expect(signals).toHaveLength(1);
+        expect(signals[0].aborted).toBe(false);
+
+        count$.reset();
+        expect(signals).toHaveLength(2);
+        expect(signals[0].aborted).toBe(true);
+        expect(signals[1].aborted).toBe(false);
+      });
+
+      it("should not create new signal on subsequent set() calls", () => {
+        let signalRef: AbortSignal | undefined;
+        const count$ = atom((ctx) => {
+          signalRef = ctx.signal;
+          return 0;
+        });
+
+        const firstSignal = signalRef;
+        count$.set(1);
+        expect(firstSignal!.aborted).toBe(true);
+
+        // After set, the signal is already aborted, no new context is created
+        // because set() doesn't re-run the initializer
+        count$.set(2);
+        expect(firstSignal!.aborted).toBe(true);
+      });
+
+      it("should abort with reason", () => {
+        let receivedSignal: AbortSignal | undefined;
+        const count$ = atom((ctx) => {
+          receivedSignal = ctx.signal;
+          return 0;
+        });
+
+        count$.set(1);
+        expect(receivedSignal!.aborted).toBe(true);
+        expect(receivedSignal!.reason).toBe("value changed");
+      });
+
+      it("should abort with 'reset' reason on reset", () => {
+        const signals: AbortSignal[] = [];
+        const count$ = atom((ctx) => {
+          signals.push(ctx.signal);
+          return 0;
+        });
+
+        count$.reset();
+        // Original signal should be aborted with 'reset' reason
+        expect(signals[0].aborted).toBe(true);
+        expect(signals[0].reason).toBe("reset");
+      });
+    });
+
+    describe("onCleanup", () => {
+      it("should call cleanup when set() is called", () => {
+        const cleanup = vi.fn();
+        const count$ = atom((ctx) => {
+          ctx.onCleanup(cleanup);
+          return 0;
+        });
+
+        expect(cleanup).not.toHaveBeenCalled();
+        count$.set(1);
+        expect(cleanup).toHaveBeenCalledTimes(1);
+      });
+
+      it("should call cleanup when reset() is called", () => {
+        const cleanup = vi.fn();
+        const count$ = atom((ctx) => {
+          ctx.onCleanup(cleanup);
+          return 0;
+        });
+
+        expect(cleanup).not.toHaveBeenCalled();
+        count$.reset();
+        expect(cleanup).toHaveBeenCalledTimes(1);
+      });
+
+      it("should call multiple cleanups in FIFO order", () => {
+        const order: number[] = [];
+        const count$ = atom((ctx) => {
+          ctx.onCleanup(() => order.push(1));
+          ctx.onCleanup(() => order.push(2));
+          ctx.onCleanup(() => order.push(3));
+          return 0;
+        });
+
+        count$.set(1);
+        expect(order).toEqual([1, 2, 3]);
+      });
+
+      it("should clear cleanups after calling them", () => {
+        const cleanup = vi.fn();
+        const count$ = atom((ctx) => {
+          ctx.onCleanup(cleanup);
+          return 0;
+        });
+
+        count$.set(1);
+        expect(cleanup).toHaveBeenCalledTimes(1);
+
+        // Second set should not call cleanup again (cleanup was from init, not from set)
+        count$.set(2);
+        expect(cleanup).toHaveBeenCalledTimes(1);
+      });
+
+      it("should call cleanup from reset, then register new cleanups on next reset", () => {
+        let cleanupCallCount = 0;
+        const count$ = atom((ctx) => {
+          ctx.onCleanup(() => cleanupCallCount++);
+          return cleanupCallCount;
+        });
+
+        expect(cleanupCallCount).toBe(0);
+
+        count$.reset();
+        expect(cleanupCallCount).toBe(1); // First cleanup called
+
+        count$.reset();
+        expect(cleanupCallCount).toBe(2); // Second cleanup called (registered in previous reset)
+      });
+
+      it("should work with async operations that check signal", async () => {
+        let cleanupCalled = false;
+        let operationAborted = false;
+
+        const data$ = atom((ctx) => {
+          ctx.onCleanup(() => {
+            cleanupCalled = true;
+          });
+
+          // Simulate an async operation that respects the signal
+          const timeoutId = setTimeout(() => {
+            if (!ctx.signal.aborted) {
+              // Would do something here
+            } else {
+              operationAborted = true;
+            }
+          }, 100);
+
+          ctx.onCleanup(() => clearTimeout(timeoutId));
+
+          return "initial";
+        });
+
+        // Trigger abort
+        data$.set("changed");
+
+        expect(cleanupCalled).toBe(true);
+
+        // Wait for the timeout to potentially fire
+        await new Promise((r) => setTimeout(r, 150));
+
+        // The operation should have been cleaned up/aborted
+        expect(operationAborted).toBe(false); // timeout was cleared by cleanup
+      });
+    });
+
+    describe("combined signal and cleanup", () => {
+      it("should abort signal and call cleanup on set", () => {
+        let signal: AbortSignal | undefined;
+        const cleanup = vi.fn();
+
+        const count$ = atom((ctx) => {
+          signal = ctx.signal;
+          ctx.onCleanup(cleanup);
+          return 0;
+        });
+
+        expect(signal!.aborted).toBe(false);
+        expect(cleanup).not.toHaveBeenCalled();
+
+        count$.set(1);
+
+        expect(signal!.aborted).toBe(true);
+        expect(cleanup).toHaveBeenCalledTimes(1);
+      });
+
+      it("should abort signal and call cleanup on reset, then provide fresh context", () => {
+        const signals: AbortSignal[] = [];
+        const cleanups: number[] = [];
+        let callCount = 0;
+
+        const count$ = atom((ctx) => {
+          callCount++;
+          signals.push(ctx.signal);
+          ctx.onCleanup(() => cleanups.push(callCount));
+          return callCount;
+        });
+
+        expect(signals).toHaveLength(1);
+        expect(cleanups).toEqual([]);
+
+        count$.reset();
+
+        expect(signals).toHaveLength(2);
+        expect(signals[0].aborted).toBe(true);
+        expect(signals[1].aborted).toBe(false);
+        expect(cleanups).toEqual([1]); // cleanup from first init was called
+      });
+    });
+
+    describe("non-function initializer (no context)", () => {
+      it("should work normally with direct value", () => {
+        const count$ = atom(42);
+        expect(count$.get()).toBe(42);
+
+        count$.set(100);
+        expect(count$.get()).toBe(100);
+
+        count$.reset();
+        expect(count$.get()).toBe(42);
+      });
+
+      it("should not have cleanup issues with direct value", () => {
+        const count$ = atom(0);
+        // These should not throw
+        count$.set(1);
+        count$.set(2);
+        count$.reset();
+        count$.reset();
+      });
+    });
+  });
+
   describe("plugin system (use)", () => {
     it("should support .use() for extensions", () => {
       // Note: Don't use ...source spread as it copies values, not getters
       // Instead, access source properties through the reference
       const base$ = atom(0);
       const count$ = base$.use((source) => ({
-        get value() {
-          return source.value;
-        },
+        get: source.get,
         set: source.set,
         reset: source.reset,
         on: source.on,
         increment: () => source.set((v) => v + 1),
       }));
 
-      expect(count$.value).toBe(0);
+      expect(count$.get()).toBe(0);
       count$.increment();
-      expect(count$.value).toBe(1);
+      expect(count$.get()).toBe(1);
     });
 
     it("should support .use() with source reference pattern", () => {
       // Simpler pattern: just reference the original atom
       const base$ = atom(0);
       const enhanced$ = base$.use(() => ({
-        get value() {
-          return base$.value;
-        },
+        get: () => base$.get(),
         increment: () => base$.set((v) => v + 1),
         decrement: () => base$.set((v) => v - 1),
       }));
 
-      expect(enhanced$.value).toBe(0);
+      expect(enhanced$.get()).toBe(0);
       enhanced$.increment();
-      expect(enhanced$.value).toBe(1);
+      expect(enhanced$.get()).toBe(1);
       enhanced$.increment();
-      expect(enhanced$.value).toBe(2);
+      expect(enhanced$.get()).toBe(2);
       enhanced$.decrement();
-      expect(enhanced$.value).toBe(1);
+      expect(enhanced$.get()).toBe(1);
     });
   });
 });