atomirx 0.0.8 → 0.1.1

package/src/core/onErrorHook.test.ts

@@ -1,350 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { atom } from "./atom";
-import { derived } from "./derived";
-import { effect } from "./effect";
-import { onErrorHook, ErrorInfo } from "./onErrorHook";
-
-describe("onErrorHook", () => {
-  beforeEach(() => {
-    onErrorHook.reset();
-  });
-
-  afterEach(() => {
-    onErrorHook.reset();
-  });
-
-  describe("with derived", () => {
-    it("should call onErrorHook when derived throws synchronously", async () => {
-      const hookFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const source$ = atom(0);
-      const derived$ = derived(
-        ({ read }) => {
-          const val = read(source$);
-          if (val > 0) {
-            throw new Error("Derived error");
-          }
-          return val;
-        },
-        { meta: { key: "testDerived" } }
-      );
-
-      await derived$.get();
-      expect(hookFn).not.toHaveBeenCalled();
-
-      // Trigger error
-      source$.set(5);
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(hookFn).toHaveBeenCalledTimes(1);
-      const info: ErrorInfo = hookFn.mock.calls[0][0];
-      expect(info.source.type).toBe("derived");
-      expect(info.source.key).toBe("testDerived");
-      expect((info.error as Error).message).toBe("Derived error");
-    });
-
-    it("should call onErrorHook when async dependency rejects", async () => {
-      const hookFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const asyncSource$ = atom(Promise.reject(new Error("Async error")));
-
-      const derived$ = derived(({ read }) => read(asyncSource$), {
-        meta: { key: "asyncDerived" },
-      });
-
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 20));
-
-      expect(hookFn).toHaveBeenCalledTimes(1);
-      const info: ErrorInfo = hookFn.mock.calls[0][0];
-      expect(info.source.type).toBe("derived");
-      expect(info.source.key).toBe("asyncDerived");
-      expect((info.error as Error).message).toBe("Async error");
-    });
-
-    it("should include derived atom in source", async () => {
-      const hookFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const source$ = atom(1);
-      const derived$ = derived(({ read }) => {
-        throw new Error("Test");
-        return read(source$);
-      });
-
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 0));
-
-      const info: ErrorInfo = hookFn.mock.calls[0][0];
-      expect(info.source.type).toBe("derived");
-      if (info.source.type === "derived") {
-        expect(info.source.instance).toBe(derived$);
-      }
-    });
-
-    it("should call both onError option and onErrorHook", async () => {
-      const hookFn = vi.fn();
-      const onErrorFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const source$ = atom(0);
-      const derived$ = derived(
-        ({ read }) => {
-          const val = read(source$);
-          if (val > 0) throw new Error("Error");
-          return val;
-        },
-        { onError: onErrorFn }
-      );
-
-      await derived$.get();
-      source$.set(1);
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(onErrorFn).toHaveBeenCalledTimes(1);
-      expect(hookFn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("with effect", () => {
-    it("should call onErrorHook with effect source when effect throws", async () => {
-      const hookFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const source$ = atom(0);
-
-      effect(
-        ({ read }) => {
-          const val = read(source$);
-          if (val > 0) {
-            throw new Error("Effect error");
-          }
-        },
-        { meta: { key: "testEffect" } }
-      );
-
-      await new Promise((r) => setTimeout(r, 0));
-      expect(hookFn).not.toHaveBeenCalled();
-
-      // Trigger error
-      source$.set(5);
-      await new Promise((r) => setTimeout(r, 10));
-
-      expect(hookFn).toHaveBeenCalledTimes(1);
-      const info: ErrorInfo = hookFn.mock.calls[0][0];
-      expect(info.source.type).toBe("effect"); // Should be effect, not derived!
-      expect(info.source.key).toBe("testEffect");
-      expect((info.error as Error).message).toBe("Effect error");
-    });
-
-    it("should include effect instance in source", async () => {
-      const hookFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const source$ = atom(1);
-      const e = effect(
-        ({ read }) => {
-          read(source$);
-          throw new Error("Test");
-        },
-        { meta: { key: "myEffect" } }
-      );
-
-      await new Promise((r) => setTimeout(r, 10));
-
-      const info: ErrorInfo = hookFn.mock.calls[0][0];
-      expect(info.source.type).toBe("effect");
-      if (info.source.type === "effect") {
-        expect(info.source.instance).toBe(e);
-      }
-    });
-
-    it("should call both onError option and onErrorHook for effect", async () => {
-      const hookFn = vi.fn();
-      const onErrorFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      const source$ = atom(0);
-
-      effect(
-        ({ read }) => {
-          const val = read(source$);
-          if (val > 0) throw new Error("Error");
-        },
-        { onError: onErrorFn }
-      );
-
-      await new Promise((r) => setTimeout(r, 0));
-      source$.set(1);
-      await new Promise((r) => setTimeout(r, 10));
-
-      expect(onErrorFn).toHaveBeenCalledTimes(1);
-      expect(hookFn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("hook behavior", () => {
-    it("should not throw when onErrorHook is not set", async () => {
-      // Hook is reset in beforeEach, so no handler is set
-
-      const source$ = atom(1);
-      const derived$ = derived(({ read }) => {
-        throw new Error("Test");
-        return read(source$);
-      });
-
-      // Should not throw
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 0));
-    });
-
-    it("should support middleware pattern with override", async () => {
-      const errors: ErrorInfo[] = [];
-
-      // First handler
-      onErrorHook.override(() => (info) => {
-        errors.push({ ...info, error: "first" });
-      });
-
-      // Add middleware - chains with previous
-      onErrorHook.override((prev) => (info) => {
-        prev?.(info);
-        errors.push({ ...info, error: "second" });
-      });
-
-      const source$ = atom(1);
-      derived(({ read }) => {
-        throw new Error("Test");
-        return read(source$);
-      })
-        .get()
-        .catch(() => {});
-
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(errors.length).toBe(2);
-      expect(errors[0].error).toBe("first");
-      expect(errors[1].error).toBe("second");
-    });
-
-    it("should support reset", async () => {
-      const hookFn = vi.fn();
-      onErrorHook.override(() => hookFn);
-
-      onErrorHook.reset();
-
-      const source$ = atom(1);
-      derived(({ read }) => {
-        throw new Error("Test");
-        return read(source$);
-      })
-        .get()
-        .catch(() => {});
-
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(hookFn).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("real-world scenarios", () => {
-    it("should enable global error logging", async () => {
-      const errorLog: Array<{ type: string; key?: string; error: string }> = [];
-
-      onErrorHook.override(() => (info) => {
-        errorLog.push({
-          type: info.source.type,
-          key: info.source.key,
-          error: String(info.error),
-        });
-      });
-
-      const source$ = atom(0);
-
-      // Create multiple derived/effects that will error
-      const derived1$ = derived(
-        ({ read }) => {
-          if (read(source$) > 0) throw new Error("Derived 1 failed");
-          return read(source$);
-        },
-        { meta: { key: "derived1" } }
-      );
-
-      const derived2$ = derived(
-        ({ read }) => {
-          if (read(source$) > 0) throw new Error("Derived 2 failed");
-          return read(source$);
-        },
-        { meta: { key: "derived2" } }
-      );
-
-      effect(
-        ({ read }) => {
-          if (read(source$) > 0) throw new Error("Effect 1 failed");
-        },
-        { meta: { key: "effect1" } }
-      );
-
-      // Trigger initial computation for derived atoms (they're lazy)
-      await derived1$.get();
-      await derived2$.get();
-      await new Promise((r) => setTimeout(r, 0));
-      expect(errorLog.length).toBe(0);
-
-      // Trigger all errors
-      source$.set(1);
-      derived1$.get().catch(() => {});
-      derived2$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 20));
-
-      expect(errorLog.length).toBe(3);
-      expect(errorLog.map((e) => e.key).sort()).toEqual([
-        "derived1",
-        "derived2",
-        "effect1",
-      ]);
-    });
-
-    it("should enable error monitoring service integration", async () => {
-      const sentryMock = {
-        captureException: vi.fn(),
-      };
-
-      onErrorHook.override(() => (info) => {
-        sentryMock.captureException(info.error, {
-          tags: {
-            source_type: info.source.type,
-            source_key: info.source.key,
-          },
-        });
-      });
-
-      const source$ = atom(1);
-      derived(
-        ({ read }) => {
-          throw new Error("Critical error");
-          return read(source$);
-        },
-        { meta: { key: "criticalDerived" } }
-      )
-        .get()
-        .catch(() => {});
-
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(sentryMock.captureException).toHaveBeenCalledWith(
-        expect.any(Error),
-        {
-          tags: {
-            source_type: "derived",
-            source_key: "criticalDerived",
-          },
-        }
-      );
-    });
-  });
-});

package/src/core/onErrorHook.ts

@@ -1,52 +0,0 @@
-import { hook } from "./hook";
-import { CreateInfo } from "./onCreateHook";
-
-/**
- * Information provided when an error occurs in an atom, derived, or effect.
- */
-export interface ErrorInfo {
-  /** The source that produced the error (atom, derived, or effect) */
-  source: CreateInfo;
-  /** The error that was thrown */
-  error: unknown;
-}
-
-/**
- * Global hook that fires whenever an error occurs in a derived atom or effect.
- *
- * This is useful for:
- * - **Global error logging** - capture all errors in one place
- * - **Error monitoring** - send errors to monitoring services (Sentry, etc.)
- * - **DevTools integration** - show errors in developer tools
- * - **Debugging** - track which atoms/effects are failing
- *
- * **IMPORTANT**: Always use `.override()` to preserve the hook chain.
- * Direct assignment to `.current` will break existing handlers.
- *
- * @example Basic logging
- * ```ts
- * onErrorHook.override((prev) => (info) => {
- *   prev?.(info); // call existing handlers first
- *   console.error(`Error in ${info.source.type}: ${info.source.key ?? "anonymous"}`, info.error);
- * });
- * ```
- *
- * @example Send to monitoring service
- * ```ts
- * onErrorHook.override((prev) => (info) => {
- *   prev?.(info); // preserve chain
- *   Sentry.captureException(info.error, {
- *     tags: {
- *       source_type: info.source.type,
- *       source_key: info.source.key,
- *     },
- *   });
- * });
- * ```
- *
- * @example Reset to default (disable all handlers)
- * ```ts
- * onErrorHook.reset();
- * ```
- */
-export const onErrorHook = hook<(info: ErrorInfo) => void>();

package/src/core/promiseCache.test.ts

@@ -1,241 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  trackPromise,
-  getPromiseState,
-  isTracked,
-  isPending,
-  isFulfilled,
-  isRejected,
-  unwrap,
-  isDerived,
-} from "./promiseCache";
-import { getAtomState } from "./getAtomState";
-import { atom } from "./atom";
-import { derived } from "./derived";
-
-describe("promiseCache", () => {
-  describe("trackPromise", () => {
-    it("should return pending state for unresolved promise", () => {
-      const promise = new Promise<number>(() => {});
-      const state = trackPromise(promise);
-      expect(state.status).toBe("pending");
-      expect((state as { promise: PromiseLike<number> }).promise).toBe(promise);
-    });
-
-    it("should return fulfilled state after promise resolves", async () => {
-      const promise = Promise.resolve(42);
-      await promise;
-      trackPromise(promise); // Start tracking
-      // May still be pending if checked immediately, wait a tick
-      await new Promise((r) => setTimeout(r, 0));
-      const state = trackPromise(promise);
-      expect(state.status).toBe("fulfilled");
-      expect((state as { value: number }).value).toBe(42);
-    });
-
-    it("should return rejected state after promise rejects", async () => {
-      const error = new Error("Test error");
-      const promise = Promise.reject(error);
-      promise.catch(() => {}); // Prevent unhandled rejection
-      trackPromise(promise); // Start tracking
-      await Promise.resolve();
-      await Promise.resolve();
-      const state = trackPromise(promise);
-      expect(state.status).toBe("rejected");
-      expect((state as { error: unknown }).error).toBe(error);
-    });
-
-    it("should return same state for same promise", () => {
-      const promise = new Promise<number>(() => {});
-      const state1 = trackPromise(promise);
-      const state2 = trackPromise(promise);
-      expect(state1).toBe(state2);
-    });
-  });
-
-  describe("getPromiseState", () => {
-    it("should return undefined for untracked promise", () => {
-      const promise = new Promise<number>(() => {});
-      expect(getPromiseState(promise)).toBe(undefined);
-    });
-
-    it("should return state for tracked promise", () => {
-      const promise = new Promise<number>(() => {});
-      trackPromise(promise);
-      expect(getPromiseState(promise)).toBeDefined();
-    });
-  });
-
-  describe("isTracked", () => {
-    it("should return false for untracked promise", () => {
-      const promise = new Promise<number>(() => {});
-      expect(isTracked(promise)).toBe(false);
-    });
-
-    it("should return true for tracked promise", () => {
-      const promise = new Promise<number>(() => {});
-      trackPromise(promise);
-      expect(isTracked(promise)).toBe(true);
-    });
-  });
-
-  describe("isPending", () => {
-    it("should return false for non-promise", () => {
-      expect(isPending(42)).toBe(false);
-      expect(isPending("hello")).toBe(false);
-      expect(isPending(null)).toBe(false);
-    });
-
-    it("should return true for pending promise", () => {
-      const promise = new Promise<number>(() => {});
-      expect(isPending(promise)).toBe(true);
-    });
-
-    it("should return false for fulfilled promise", async () => {
-      const promise = Promise.resolve(42);
-      trackPromise(promise); // Start tracking
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(isPending(promise)).toBe(false);
-    });
-  });
-
-  describe("isFulfilled", () => {
-    it("should return false for non-promise", () => {
-      expect(isFulfilled(42)).toBe(false);
-    });
-
-    it("should return true for fulfilled promise", async () => {
-      const promise = Promise.resolve(42);
-      trackPromise(promise);
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(isFulfilled(promise)).toBe(true);
-    });
-
-    it("should return false for pending promise", () => {
-      const promise = new Promise<number>(() => {});
-      expect(isFulfilled(promise)).toBe(false);
-    });
-  });
-
-  describe("isRejected", () => {
-    it("should return false for non-promise", () => {
-      expect(isRejected(42)).toBe(false);
-    });
-
-    it("should return true for rejected promise", async () => {
-      const promise = Promise.reject(new Error("test"));
-      promise.catch(() => {});
-      trackPromise(promise);
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(isRejected(promise)).toBe(true);
-    });
-
-    it("should return false for fulfilled promise", async () => {
-      const promise = Promise.resolve(42);
-      trackPromise(promise);
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(isRejected(promise)).toBe(false);
-    });
-  });
-
-  describe("unwrap", () => {
-    it("should return value for non-promise", () => {
-      expect(unwrap(42)).toBe(42);
-      expect(unwrap("hello")).toBe("hello");
-      expect(unwrap(null)).toBe(null);
-    });
-
-    it("should return value for fulfilled promise", async () => {
-      const promise = Promise.resolve(42);
-      trackPromise(promise);
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(unwrap(promise)).toBe(42);
-    });
-
-    it("should throw promise for pending promise", () => {
-      const promise = new Promise<number>(() => {});
-      let thrown: unknown;
-      try {
-        unwrap(promise);
-      } catch (e) {
-        thrown = e;
-      }
-      expect(thrown).toBe(promise);
-    });
-
-    it("should throw error for rejected promise", async () => {
-      const error = new Error("Test error");
-      const promise = Promise.reject(error);
-      promise.catch(() => {});
-      trackPromise(promise);
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(() => unwrap(promise)).toThrow(error);
-    });
-  });
-
-  describe("isDerived", () => {
-    it("should return false for mutable atom", () => {
-      const a$ = atom(0);
-      expect(isDerived(a$)).toBe(false);
-    });
-
-    it("should return true for derived atom", () => {
-      const a$ = atom(0);
-      const d$ = derived(({ read }) => read(a$) * 2);
-      expect(isDerived(d$)).toBe(true);
-    });
-
-    it("should return false for non-atom values", () => {
-      expect(isDerived(null)).toBe(false);
-      expect(isDerived(undefined)).toBe(false);
-      expect(isDerived(42)).toBe(false);
-      expect(isDerived({})).toBe(false);
-    });
-  });
-
-  describe("getAtomState", () => {
-    it("should return ready state for sync mutable atom", () => {
-      const a$ = atom(42);
-      const state = getAtomState(a$);
-      expect(state.status).toBe("ready");
-      expect((state as { value: number }).value).toBe(42);
-    });
-
-    it("should return loading state for atom with pending Promise", () => {
-      const promise = new Promise<number>(() => {});
-      const a$ = atom(promise);
-      const state = getAtomState(a$);
-      expect(state.status).toBe("loading");
-    });
-
-    it("should return ready state for atom with resolved Promise", async () => {
-      const promise = Promise.resolve(42);
-      const a$ = atom(promise);
-      trackPromise(promise);
-      await Promise.resolve();
-      await Promise.resolve();
-      const state = getAtomState(a$);
-      expect(state.status).toBe("ready");
-      expect((state as { value: number }).value).toBe(42);
-    });
-
-    it("should return loading state for derived with fallback during loading", async () => {
-      const asyncValue$ = atom(new Promise<number>(() => {}));
-      const derived$ = derived(({ read }) => read(asyncValue$), {
-        fallback: 0,
-      });
-
-      // Derived atoms return their state directly via state()
-      // State is loading, but staleValue provides the fallback
-      const state = getAtomState(derived$);
-      expect(state.status).toBe("loading");
-      expect(derived$.staleValue).toBe(0);
-    });
-  });
-});