@praxisjs/core 1.6.0 → 1.7.0

package/src/async/resource.ts

@@ -1,7 +1,16 @@
 import type { Computed, Signal } from "@praxisjs/shared";
 
 import { computed, signal } from "../signal";
-import { effect } from "../signal/effect";
+import {
+  getCacheEntry,
+  setCacheEntry,
+  deleteInflight,
+  getInflight,
+  setInflight,
+  registerResource,
+  unregisterResource,
+} from "./resource-cache";
+import { effect, untrack } from "../signal/effect";
 
 export type ResourceStatus = "idle" | "pending" | "success" | "error";
 
@@ -13,12 +22,16 @@ export interface Resource<T> {
   refetch(): void;
   cancel(): void;
   mutate(data: T): void;
+  destroy(): void;
 }
 
 export interface ResourceOptions<T> {
   initialData?: T;
   immediate?: boolean;
   keepPreviousData?: boolean;
+  key?: string;
+  staleTime?: number;
+  refetchOnFocus?: boolean;
 }
 
 export function resource<T>(
@@ -29,18 +42,27 @@ export function resource<T>(
     initialData = null,
     immediate = true,
     keepPreviousData = false,
+    key,
+    staleTime = 0,
+    refetchOnFocus = false,
   } = options;
 
-  const _data = signal(initialData);
+  const cached = key ? getCacheEntry(key) : undefined;
+  const isCacheFresh =
+    cached !== undefined && Date.now() - cached.timestamp < staleTime;
+
+  const _data = signal(cached ? (cached.data as T) : initialData);
   const _error = signal<Error | null>(null);
-  const _status = signal<ResourceStatus>("idle");
+  const _status = signal<ResourceStatus>(cached ? "success" : "idle");
 
   let _runId = 0;
 
-  function _execute(fn: Promise<T>) {
+  function _execute(fn: Promise<T>): void {
     const currentRunId = ++_runId;
 
-    if (!keepPreviousData) {
+    // untrack: _data.set(result) in the resolve handler must not re-trigger the enclosing effect.
+    const hasCachedData = key !== undefined && untrack(() => _data()) !== null;
+    if (!keepPreviousData && !hasCachedData) {
       _data.set(null);
     }
     _error.set(null);
@@ -51,16 +73,36 @@ export function resource<T>(
       _data.set(result);
       _error.set(null);
       _status.set("success");
+      if (key) {
+        setCacheEntry(key, result);
+        deleteInflight(key);
+      }
     }).catch((err: unknown) => {
       if (currentRunId !== _runId) return;
       _error.set(err instanceof Error ? err : new Error(String(err)));
       _status.set("error");
+      if (key) deleteInflight(key);
     });
   }
 
-  function execute() {
-    try {
+  function _startFetch(): void {
+    if (key) {
+      const existing = getInflight(key);
+      if (existing) {
+        _execute(existing as Promise<T>);
+        return;
+      }
+      const promise = fetcher();
+      setInflight(key, promise as Promise<unknown>);
+      _execute(promise);
+    } else {
       _execute(fetcher());
+    }
+  }
+
+  function execute(): void {
+    try {
+      _startFetch();
     } catch (err: unknown) {
       _runId++;
       _error.set(err instanceof Error ? err : new Error(String(err)));
@@ -68,17 +110,56 @@ export function resource<T>(
     }
   }
 
-  if (immediate) {
-    effect(() => {
+  if (key) {
+    registerResource(key, execute);
+  }
+
+  let stopEffect: (() => void) | undefined;
+
+  if (immediate && !isCacheFresh) {
+    stopEffect = effect(() => {
       try {
-        _execute(fetcher());
+        if (key) {
+          const existing = getInflight(key);
+          if (existing) {
+            _execute(existing as Promise<T>);
+          } else {
+            const promise = fetcher();
+            setInflight(key, promise as Promise<unknown>);
+            _execute(promise);
+          }
+        } else {
+          _execute(fetcher());
+        }
       } catch (err: unknown) {
+        _runId++;
         _error.set(err instanceof Error ? err : new Error(String(err)));
         _status.set("error");
       }
     });
   }
 
+  let _removeFocusListener: (() => void) | undefined;
+  if (refetchOnFocus && typeof document !== "undefined") {
+    const onVisibility = (): void => {
+      if (document.visibilityState === "visible") {
+        execute();
+      }
+    };
+    document.addEventListener("visibilitychange", onVisibility);
+    _removeFocusListener = (): void => {
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }
+
+  function destroy(): void {
+    stopEffect?.();
+    stopEffect = undefined;
+    _removeFocusListener?.();
+    _removeFocusListener = undefined;
+    if (key) unregisterResource(key, execute);
+  }
+
   return {
     data: computed(() => _data()),
     pending: computed(() => _status() === "pending"),
@@ -97,6 +178,7 @@ export function resource<T>(
       _error.set(null);
       _status.set("success");
     },
+    destroy,
   };
 }
 

package/src/internal.ts

@@ -25,3 +25,4 @@ export {
   type Resource,
   type ResourceOptions,
 } from "./async/resource";
+export { invalidateResource, _clearCache } from "./async/resource-cache";

package/src/reactive/reactive.ts

@@ -45,7 +45,6 @@ export function debounced<T>(source: Signal<T> | Computed<T>, ms: number) {
 
   const stop = effect(() => {
     const value = source();
-    if (timeout) clearTimeout(timeout);
     timeout = setTimeout(() => {
       current.set(value);
       timeout = undefined;