@kawaiininja/fetch 1.0.54 → 1.0.55

package/dist/hooks/useFetch.js

@@ -9,9 +9,28 @@ export const useFetch = (endpoint, baseOptions = {}) => {
     const { fetchCSRF } = useCsrf();
     const abortRef = useRef(new AbortController());
     const mounted = useRef(true);
-    const { enabled = true, swr = false, staleTime = 300000, timeout = globalTimeout, retries = globalRetries, } = baseOptions;
-    const mergedOptions = { ...baseOptions, timeout, retries };
-    const cacheKey = useMemo(() => baseOptions.dedupeKey || endpoint, [endpoint, baseOptions.dedupeKey]);
+    const { enabled = true, swr = false, staleTime = 300000, timeout = globalTimeout, retries = globalRetries, revalidateOnFocus, refreshInterval, dedupeKey, } = baseOptions;
+    // 🛡️ STABILIZE OPTIONS: Prevent identity-based loops by memoizing primitives
+    const stableOptions = useMemo(() => ({
+        enabled,
+        swr,
+        staleTime,
+        timeout,
+        retries,
+        revalidateOnFocus,
+        refreshInterval,
+        dedupeKey,
+    }), [
+        enabled,
+        swr,
+        staleTime,
+        timeout,
+        retries,
+        revalidateOnFocus,
+        refreshInterval,
+        dedupeKey,
+    ]);
+    const cacheKey = useMemo(() => dedupeKey || endpoint, [endpoint, dedupeKey]);
     const cached = getCache(cacheKey);
     const [state, setState] = useState({
         data: cached?.data || null,
@@ -22,15 +41,12 @@ export const useFetch = (endpoint, baseOptions = {}) => {
     const safeSet = useCallback((fn) => {
         if (!mounted.current)
             return;
-        // Immediate update to prevent stale closures and lost updates
         setState((prev) => ({ ...prev, ...fn(prev) }));
     }, []);
     const request = useCallback(async (params = {}) => {
         const isRead = !params.method || params.method === "GET";
         const currentCache = getCache(cacheKey);
         if (isRead && currentCache?.promise) {
-            // 🔌 TAP-IN: If a request is already flying (e.g. from StrictMode or another component),
-            // we must attach OUR state updater to it, otherwise we'll stay in 'loading: true' forever.
             currentCache.promise.then((data) => safeSet(() => ({ data, status: 200, loading: false })), (err) => safeSet(() => ({
                 error: err.message || "Network Error",
                 status: null,
@@ -41,13 +57,13 @@ export const useFetch = (endpoint, baseOptions = {}) => {
         if (!currentCache?.data)
             safeSet(() => ({ loading: true, error: null }));
         const execution = (async () => {
-            const reqId = cacheKey; // Simple ID for logging
+            const reqId = cacheKey;
             if (debug)
                 console.log(`[useFetch] 🚀 Starting ${reqId}`);
             try {
                 const token = await fetchCSRF();
                 const finalUrl = apiUrl(params.url || endpoint);
-                const res = await performFetch(finalUrl, params.method || "GET", token, params.body, params.headers, { ...mergedOptions, ...params }, debug, abortRef.current.signal, apiUrl);
+                const res = await performFetch(finalUrl, params.method || "GET", token, params.body, params.headers, { ...stableOptions, ...params }, debug, abortRef.current.signal, apiUrl);
                 const parsed = await parseResponse(res, params.parseAs || "auto");
                 if (!res.ok)
                     throw new Error(parsed?.message || res.statusText);
@@ -56,7 +72,6 @@ export const useFetch = (endpoint, baseOptions = {}) => {
                 if (debug)
                     console.log(`[useFetch] ✅ Success ${reqId}`, {
                         mounted: mounted.current,
-                        data: parsed,
                     });
                 safeSet(() => ({ data: parsed, status: res.status, loading: false }));
                 return parsed;
@@ -71,10 +86,6 @@ export const useFetch = (endpoint, baseOptions = {}) => {
                         onError(msg, null);
                     throw err;
                 }
-                else {
-                    if (debug)
-                        console.warn(`[useFetch] 🛑 Aborted ${reqId}`);
-                }
             }
             finally {
                 if (isRead) {
@@ -98,37 +109,36 @@ export const useFetch = (endpoint, baseOptions = {}) => {
         onError,
         debug,
         safeSet,
-        baseOptions,
+        stableOptions,
     ]);
+    // 🔄 TRIGGER FETCH
     useEffect(() => {
         if (!enabled)
             return;
-        const shouldFetch = !cached?.data || (swr && isStale(cacheKey, staleTime));
+        // Check cache directly inside effect for freshest state without re-triggering dependency
+        const currentCache = getCache(cacheKey);
+        const shouldFetch = !currentCache?.data || (swr && isStale(cacheKey, staleTime));
         if (shouldFetch) {
             request();
         }
-    }, [enabled, cacheKey, swr, staleTime, request, cached?.data]);
+    }, [enabled, cacheKey, swr, staleTime, request]);
     useEffect(() => {
-        if (!baseOptions.revalidateOnFocus || !enabled)
+        if (!revalidateOnFocus || !enabled)
             return;
         const onFocus = () => request();
         window.addEventListener("focus", onFocus);
         return () => window.removeEventListener("focus", onFocus);
-    }, [request, baseOptions.revalidateOnFocus, enabled]);
+    }, [request, revalidateOnFocus, enabled]);
     useEffect(() => {
-        if (!baseOptions.refreshInterval || !enabled)
+        if (!refreshInterval || !enabled)
             return;
-        const timer = setInterval(() => request(), baseOptions.refreshInterval);
+        const timer = setInterval(() => request(), refreshInterval);
         return () => clearInterval(timer);
-    }, [request, baseOptions.refreshInterval, enabled]);
+    }, [request, refreshInterval, enabled]);
     useEffect(() => {
         mounted.current = true;
         return () => {
             mounted.current = false;
-            // 🛡️ STRICT MODE FIX: Do not abort requests on unmount.
-            // In React 18 Strict Mode, the first mount starts the request, then unmounts immediately.
-            // If we abort here, the shared promise (used by the second mount) dies, leaving the app in 'loading: true'.
-            // abortRef.current.abort();
         };
     }, []);
     const methods = createApiMethods({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kawaiininja/fetch",
-    "version": "1.0.54",
+    "version": "1.0.55",
     "description": "Core fetch utility for Onyx Framework",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",