@kawaiininja/fetch 1.0.23 → 1.0.25

package/dist/context/ApiContext.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useMemo } from "react";
+import { createContext, useCallback, useEffect, useMemo, useRef } from "react";
 /**
  * Internal service header for API requests
  */
@@ -14,39 +14,26 @@ export const ApiContext = createContext(null);
  * Constructs full API URLs from relative paths using the baseUrl.
  */
 export function ApiProvider({ config, children }) {
-    // 🛡️ STABILITY: Hash the config to detect REAL changes vs identity shifts
-    const configHash = useMemo(() => {
-        try {
-            return JSON.stringify({
-                baseUrl: config?.baseUrl,
-                version: config?.version,
-                debug: config?.debug,
-                // We can't stringify functions, so we use their existence/identity
-                hasOnError: !!config?.onError,
-            });
-        }
-        catch {
-            return Math.random();
-        }
-    }, [config?.baseUrl, config?.version, config?.debug, config?.onError]);
-    // Extract stable values based on the hash
-    const { baseUrl, version, debug, onError } = useMemo(() => ({
-        baseUrl: config?.baseUrl || "",
-        version: config?.version || "v1",
-        debug: !!config?.debug,
-        onError: config?.onError,
-    }), [configHash]);
-    /**
-     * 🛡️ HYPER-STABLE URL CONSTRUCTOR
-     * Memoized independently of the context value to prevent downstream loop invalidation.
-     */
+    // 1. STABILITY: Use a Ref to hold the baseUrl to avoid apiUrl re-creations
+    const baseUrlRef = useRef(config?.baseUrl || "");
+    useEffect(() => {
+        baseUrlRef.current = config?.baseUrl || "";
+    }, [config?.baseUrl]);
+    // 2. STABLE URL CONSTRUCTOR: This function now NEVER changes identity
     const apiUrl = useCallback((path) => {
+        const baseUrl = baseUrlRef.current;
         if (path.startsWith("http"))
             return path;
         const cleanBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
         const cleanPath = path.startsWith("/") ? path : `/${path}`;
         return `${cleanBase}${cleanPath}`;
-    }, [baseUrl]);
+    }, []);
+    // 3. INTERNAL STABILITY: Memoize primitive values strictly
+    const baseUrl = config?.baseUrl || "";
+    const version = config?.version || "v1";
+    const debug = !!config?.debug;
+    const onError = config?.onError;
+    // 4. VALUE MEMOIZATION: Only re-create context if primitives change
     const value = useMemo(() => ({
         baseUrl,
         version,

package/dist/hooks/useFetch.js

@@ -43,8 +43,12 @@ export const useFetch = (endpoint, baseOptions = {}) => {
     const safeSet = useCallback((fn) => {
         if (!mounted.current)
             return;
-        if (isUpdatingRef.current)
-            return; // Block synchronous recursion
+        // If we are already in an update cycle, queue the next one
+        // instead of running it synchronously.
+        if (isUpdatingRef.current) {
+            setTimeout(() => safeSet(fn), 0);
+            return;
+        }
         isUpdatingRef.current = true;
         try {
             setState((prev) => {
@@ -58,65 +62,74 @@ export const useFetch = (endpoint, baseOptions = {}) => {
             });
         }
         finally {
-            // Use a microtask to release the lock after the current execution frame
+            // Ensure the lock is released in the next microtask
+            // This clears the stack and prevents the "Background" pile-up
             Promise.resolve().then(() => {
                 isUpdatingRef.current = false;
             });
         }
     }, [endpoint, debug]);
+    // 🛡️ INTERNAL STABILITY: Decouple from context identity
+    const apiUrlRef = useRef(apiUrl);
+    useEffect(() => {
+        apiUrlRef.current = apiUrl;
+    }, [apiUrl]);
     const request = useCallback(async (params = {}) => {
-        // 🛡️ RECURSION GUARD: Instant rejection of concurrent loops
-        if (isRequestingRef.current) {
-            if (debug)
-                console.warn("[useFetch] 🔥 RECURSION GUARD: Blocking concurrent call.");
-            return;
-        }
-        const { url = endpoint, method = "GET", body, headers, parseAs = "auto", ...rest } = params;
-        const finalUrl = url.startsWith("http") ? url : apiUrl(url);
-        if (!finalUrl)
+        if (isRequestingRef.current)
             return;
         isRequestingRef.current = true;
-        safeSet(() => ({ loading: true, error: null }));
-        let lastStatus = null;
-        try {
-            let token = await fetchCSRF();
-            // Merge baseOptions from Ref to maintain identity stability
-            let res = await performFetch(finalUrl, method, token, body, headers, { ...optionsRef.current, ...rest }, debug, abortRef.current.signal, apiUrl);
-            lastStatus = res.status;
-            // Auto-retry on 403 CSRF Error
-            if (res.status === 403) {
-                const bodyClone = await res
-                    .clone()
-                    .json()
-                    .catch(() => ({}));
-                if (bodyClone?.code === "CSRF_ERROR" || bodyClone?.message?.includes("CSRF")) {
-                    await clearCsrf();
-                    token = await fetchCSRF();
-                    res = await performFetch(finalUrl, method, token, body, headers, { ...optionsRef.current, ...rest }, debug, abortRef.current.signal, apiUrl);
-                    lastStatus = res.status;
+        // 🛡️ STACK BREAK: Use a microtask to start the request
+        // This ensures the calling function can finish and "End" before fetch starts
+        return await Promise.resolve().then(async () => {
+            const { url = endpoint, method = "GET", body, headers, parseAs = "auto", ...rest } = params;
+            // Use Ref to prevent re-creation of request when Context changes
+            const finalUrl = url.startsWith("http") ? url : apiUrlRef.current(url);
+            if (!finalUrl) {
+                isRequestingRef.current = false;
+                return;
+            }
+            safeSet(() => ({ loading: true, error: null }));
+            let lastStatus = null;
+            try {
+                let token = await fetchCSRF();
+                // Merge baseOptions from Ref to maintain identity stability
+                let res = await performFetch(finalUrl, method, token, body, headers, { ...optionsRef.current, ...rest }, debug, abortRef.current.signal, apiUrlRef.current);
+                lastStatus = res.status;
+                // Auto-retry on 403 CSRF Error
+                if (res.status === 403) {
+                    const bodyClone = await res
+                        .clone()
+                        .json()
+                        .catch(() => ({}));
+                    if (bodyClone?.code === "CSRF_ERROR" || bodyClone?.message?.includes("CSRF")) {
+                        await clearCsrf();
+                        token = await fetchCSRF();
+                        res = await performFetch(finalUrl, method, token, body, headers, { ...optionsRef.current, ...rest }, debug, abortRef.current.signal, apiUrlRef.current);
+                        lastStatus = res.status;
+                    }
                 }
+                const parsed = await parseResponse(res, parseAs);
+                if (!res.ok)
+                    throw new Error(parsed?.message || res.statusText);
+                safeSet(() => ({ data: parsed, status: res.status }));
+                return parsed;
             }
-            const parsed = await parseResponse(res, parseAs);
-            if (!res.ok)
-                throw new Error(parsed?.message || res.statusText);
-            safeSet(() => ({ data: parsed, status: res.status }));
-            return parsed;
-        }
-        catch (err) {
-            if (err.name !== "AbortError") {
-                safeSet(() => ({ error: err.message, status: lastStatus }));
-                if (onError)
-                    onError(err.message, lastStatus);
-                throw err;
+            catch (err) {
+                if (err.name !== "AbortError") {
+                    safeSet(() => ({ error: err.message, status: lastStatus }));
+                    if (onError)
+                        onError(err.message, lastStatus);
+                    throw err;
+                }
             }
-        }
-        finally {
-            safeSet(() => ({ loading: false }));
-            isRequestingRef.current = false;
-        }
+            finally {
+                safeSet(() => ({ loading: false }));
+                isRequestingRef.current = false;
+            }
+        });
     }, 
-    // baseOptions REMOVED from dependencies to prevent infinite request recreation
-    [endpoint, fetchCSRF, clearCsrf, apiUrl, safeSet, onError, debug]);
+    // apiUrl REMOVED specific dependency to stop context-based invalidations
+    [endpoint, fetchCSRF, clearCsrf, safeSet, onError, debug]);
     useEffect(() => {
         mounted.current = true;
         return () => {

package/package.json

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