atomirx 0.0.1 → 0.0.4

package/src/core/promiseCache.test.ts

@@ -7,9 +7,9 @@ import {
   isFulfilled,
   isRejected,
   unwrap,
-  getAtomState,
   isDerived,
 } from "./promiseCache";
+import { getAtomState } from "./getAtomState";
 import { atom } from "./atom";
 import { derived } from "./derived";
 
@@ -187,7 +187,7 @@ describe("promiseCache", () => {
 
     it("should return true for derived atom", () => {
       const a$ = atom(0);
-      const d$ = derived(({ get }) => get(a$) * 2);
+      const d$ = derived(({ read }) => read(a$) * 2);
       expect(isDerived(d$)).toBe(true);
     });
 
@@ -227,7 +227,9 @@ describe("promiseCache", () => {
 
     it("should return loading state for derived with fallback during loading", async () => {
       const asyncValue$ = atom(new Promise<number>(() => {}));
-      const derived$ = derived(({ get }) => get(asyncValue$), { fallback: 0 });
+      const derived$ = derived(({ read }) => read(asyncValue$), {
+        fallback: 0,
+      });
 
       // Derived atoms return their state directly via state()
       // State is loading, but staleValue provides the fallback

package/src/core/promiseCache.ts

@@ -1,5 +1,80 @@
+import { shallow2Equal } from "./equality";
 import { isPromiseLike } from "./isPromiseLike";
-import { Atom, AtomState, DerivedAtom, SYMBOL_DERIVED } from "./types";
+import { AnyFunc, DerivedAtom, SYMBOL_DERIVED } from "./types";
+
+/**
+ * Metadata attached to combined promises for comparison.
+ */
+export interface CombinedPromiseMeta {
+  type: "all" | "race" | "allSettled";
+  promises: Promise<unknown>[];
+}
+
+/**
+ * WeakMap cache for combined promise metadata.
+ * Using WeakMap allows promises to be garbage collected when no longer referenced.
+ */
+const combinedPromiseCache = new WeakMap<
+  PromiseLike<unknown>,
+  CombinedPromiseMeta
+>();
+
+/**
+ * Gets the metadata for a combined promise, if any.
+ * Used internally by promisesEqual for comparison.
+ */
+export function getCombinedPromiseMetadata(
+  promise: PromiseLike<unknown>
+): CombinedPromiseMeta | undefined {
+  return combinedPromiseCache.get(promise);
+}
+
+/**
+ * Create a combined promise with metadata for comparison.
+ * If only one promise, returns it directly (no metadata needed).
+ */
+export function createCombinedPromise(
+  type: "all" | "race" | "allSettled",
+  promises: Promise<unknown>[]
+): PromiseLike<unknown> {
+  if (promises.length === 1) {
+    // Single promise - no need for metadata, just return it
+    // For allSettled, we still need to wrap to prevent rejection propagation
+    if (type === "allSettled") {
+      const combined = Promise.allSettled(promises).then(() => undefined);
+      combinedPromiseCache.set(combined, { type, promises });
+      return combined;
+    }
+    return promises[0];
+  }
+
+  const combined = (Promise[type] as AnyFunc)(promises);
+  // Attach no-op catch to prevent unhandled rejection warnings
+  combined.catch(() => {});
+  combinedPromiseCache.set(combined, { type, promises });
+  return combined;
+}
+
+/**
+ * Compare two promises, considering combined promise metadata.
+ * Returns true if promises are considered equal.
+ */
+export function promisesEqual(
+  a: PromiseLike<unknown> | undefined,
+  b: PromiseLike<unknown> | undefined
+): boolean {
+  // Same reference
+  if (a === b) return true;
+
+  // One is undefined
+  if (!a || !b) return false;
+
+  // Compare by metadata (type + source promises array)
+  const metaA = getCombinedPromiseMetadata(a);
+  const metaB = getCombinedPromiseMetadata(b);
+
+  return !!metaA && !!metaB && shallow2Equal(metaA, metaB);
+}
 
 /**
  * Represents the state of a tracked Promise.
@@ -98,76 +173,6 @@ export function isDerived<T>(value: unknown): value is DerivedAtom<T, boolean> {
   );
 }
 
-/**
- * Returns the current state of an atom as a discriminated union.
- *
- * For DerivedAtom:
- * - Returns atom.state() directly (derived atoms track their own state)
- *
- * For MutableAtom:
- * - If value is not a Promise: returns ready state
- * - If value is a Promise: tracks and returns its state (ready/error/loading)
- *
- * @param atom - The atom to get state from
- * @returns AtomState discriminated union (ready | error | loading)
- *
- * @example
- * ```ts
- * const state = getAtomState(myAtom$);
- *
- * switch (state.status) {
- *   case "ready":
- *     console.log(state.value); // T
- *     break;
- *   case "error":
- *     console.log(state.error);
- *     break;
- *   case "loading":
- *     console.log(state.promise);
- *     break;
- * }
- * ```
- */
-export function getAtomState<T>(atom: Atom<T>): AtomState<Awaited<T>> {
-  // For derived atoms, use their own state method
-  if (isDerived<T>(atom)) {
-    return atom.state() as AtomState<Awaited<T>>;
-  }
-
-  const value = atom.value;
-
-  // 1. Sync value - ready
-  if (!isPromiseLike(value)) {
-    return {
-      status: "ready",
-      value: value as Awaited<T>,
-    };
-  }
-
-  // 2. Promise value - check state via promiseCache
-  const state = trackPromise(value);
-
-  switch (state.status) {
-    case "fulfilled":
-      return {
-        status: "ready",
-        value: state.value as Awaited<T>,
-      };
-
-    case "rejected":
-      return {
-        status: "error",
-        error: state.error,
-      };
-
-    case "pending":
-      return {
-        status: "loading",
-        promise: state.promise as Promise<Awaited<T>>,
-      };
-  }
-}
-
 /**
  * Unwraps a value that may be a Promise.
  * - If not a Promise, returns the value directly.