@kawaiininja/fetch 1.0.24 → 1.0.26

package/dist/context/ApiContext.d.ts

@@ -1,7 +1,4 @@
 import React from "react";
-/**
- * Internal service header for API requests
- */
 export declare const INTERNAL_HEADER: {
     readonly "x-internal-service": "zevrinix-main";
 };
@@ -11,9 +8,6 @@ export interface ApiConfig {
     onError?: (error: string, status: number | null) => void;
     debug?: boolean;
 }
-/**
- * API context value type
- */
 export interface ApiContextValue {
     baseUrl: string;
     version: string;
@@ -21,9 +15,6 @@ export interface ApiContextValue {
     onError?: (error: string, status: number | null) => void;
     debug: boolean;
 }
-/**
- * Props for ApiProvider component
- */
 export interface ApiProviderProps {
     config: ApiConfig;
     children: React.ReactNode;
@@ -31,8 +22,6 @@ export interface ApiProviderProps {
 export declare const ApiContext: React.Context<ApiContextValue | null>;
 /**
  * ApiProvider
- *
- * Provides API configuration to the component tree.
- * Constructs full API URLs from relative paths using the baseUrl.
+ * 🛡️ GOD-LEVEL STABILITY: Identity is decoupled from config reference
  */
 export declare function ApiProvider({ config, children }: ApiProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/context/ApiContext.js

@@ -1,58 +1,43 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useMemo } from "react";
-/**
- * Internal service header for API requests
- */
+import { createContext, useCallback, useEffect, useMemo, useRef } from "react";
 export const INTERNAL_HEADER = {
     "x-internal-service": "zevrinix-main",
 };
 export const ApiContext = createContext(null);
 /**
  * ApiProvider
- *
- * Provides API configuration to the component tree.
- * Constructs full API URLs from relative paths using the baseUrl.
+ * 🛡️ GOD-LEVEL STABILITY: Identity is decoupled from config reference
  */
 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]);
+    // Use refs for values that change but shouldn't break the identity of helpers
+    const baseUrlRef = useRef(config?.baseUrl || "");
+    const onErrorRef = useRef(config?.onError);
+    useEffect(() => {
+        baseUrlRef.current = config?.baseUrl || "";
+        onErrorRef.current = config?.onError;
+    }, [config?.baseUrl, config?.onError]);
     /**
-     * 🛡️ HYPER-STABLE URL CONSTRUCTOR
-     * Memoized independently of the context value to prevent downstream loop invalidation.
+     * 🛡️ PERMANENT IDENTITY URL CONSTRUCTOR
+     * This function's reference NEVER changes, stopping the downstream loop chain.
      */
     const apiUrl = useCallback((path) => {
+        const base = baseUrlRef.current;
         if (path.startsWith("http"))
             return path;
-        const cleanBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+        const cleanBase = base.endsWith("/") ? base.slice(0, -1) : base;
         const cleanPath = path.startsWith("/") ? path : `/${path}`;
         return `${cleanBase}${cleanPath}`;
-    }, [baseUrl]);
+    }, []);
+    // Memoize primitive values only
+    const baseUrl = config?.baseUrl || "";
+    const version = config?.version || "v1";
+    const debug = !!config?.debug;
     const value = useMemo(() => ({
         baseUrl,
         version,
         debug,
-        onError,
         apiUrl,
-    }), [baseUrl, version, debug, onError, apiUrl]);
+        onError: (err, status) => onErrorRef.current?.(err, status),
+    }), [baseUrl, version, debug, apiUrl]);
     return _jsx(ApiContext.Provider, { value: value, children: children });
 }

package/dist/hooks/useFetch.d.ts

@@ -2,6 +2,6 @@ import { ApiSurface } from "./utils";
 export { clearNativeAuthVault } from "./useFetch.vault";
 /**
  * useFetch Hook
- * 🛡️ STABILITY UPGRADE: Reference Stability + Internal Recursion Guard
+ * 🛡️ STACK PROTECTION: Logic flattening + Identity Locking
  */
 export declare const useFetch: <T = any>(endpoint: string, baseOptions?: any) => ApiSurface<T>;

package/dist/hooks/useFetch.js

@@ -6,113 +6,64 @@ import { createApiMethods } from "./utils";
 export { clearNativeAuthVault } from "./useFetch.vault";
 /**
  * useFetch Hook
- * 🛡️ STABILITY UPGRADE: Reference Stability + Internal Recursion Guard
+ * 🛡️ STACK PROTECTION: Logic flattening + Identity Locking
  */
 export const useFetch = (endpoint, baseOptions = {}) => {
     const { apiUrl, onError, debug } = useApiConfig();
-    const { fetchCSRF, clearCsrf } = useCsrf();
-    const runsRef = useRef(0);
+    const { fetchCSRF } = useCsrf();
     const abortRef = useRef(new AbortController());
     const mounted = useRef(true);
     const isRequestingRef = useRef(false);
-    // 🛡️ STABILITY: Options hashing to prevent unnecessary effect triggers from object literals
+    // 🛡️ IDENTITY LOCK: Decouple options from render cycle
     const optionsRef = useRef(baseOptions);
-    const optionsHash = useMemo(() => {
-        try {
-            return JSON.stringify(baseOptions);
-        }
-        catch {
-            return Math.random();
-        }
-    }, [baseOptions]);
     useEffect(() => {
-        if (debug)
-            console.log(`[useFetch] [${endpoint}] ⚙️ baseOptions updated`);
         optionsRef.current = baseOptions;
-    }, [optionsHash, endpoint, debug]);
-    if (debug)
-        console.log(`[useFetch] [${endpoint}] 🔄 Hook Render`);
+    }, [JSON.stringify(baseOptions)]); // Only update ref if content actually changes
     const [state, setState] = useState({
         data: null,
         loading: false,
         error: null,
         status: null,
     });
-    // 🛡️ RECURSION GUARD: Prevent synchronous state-update cascades
-    const isUpdatingRef = useRef(false);
+    /**
+     * 🛡️ STACK FLATTENER
+     * Pushes state updates to the microtask queue.
+     * This forces the current function to "Return" and clear the stack before next render.
+     */
     const safeSet = useCallback((fn) => {
         if (!mounted.current)
             return;
-        if (isUpdatingRef.current)
-            return; // Block synchronous recursion
-        isUpdatingRef.current = true;
-        try {
-            setState((prev) => {
-                const updates = fn(prev);
-                if (debug) {
-                    console.groupCollapsed(`[useFetch] [${endpoint}] 🔄 State Update`);
-                    console.log("Updates:", updates);
-                    console.groupEnd();
-                }
-                return { ...prev, ...updates };
-            });
-        }
-        finally {
-            // Use a microtask to release the lock after the current execution frame
-            Promise.resolve().then(() => {
-                isUpdatingRef.current = false;
-            });
-        }
-    }, [endpoint, debug]);
-    // 🛡️ INTERNAL STABILITY: Decouple from context identity
-    const apiUrlRef = useRef(apiUrl);
-    useEffect(() => {
-        apiUrlRef.current = apiUrl;
-    }, [apiUrl]);
+        queueMicrotask(() => {
+            setState((prev) => ({ ...prev, ...fn(prev) }));
+        });
+    }, []);
     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;
-        // Use Ref to prevent re-creation of request when Context changes
-        const finalUrl = url.startsWith("http") ? url : apiUrlRef.current(url);
-        if (!finalUrl)
+        if (isRequestingRef.current)
             return;
         isRequestingRef.current = true;
+        if (debug)
+            console.log(`[useFetch] [${endpoint}] 🚀 Starting Request`);
         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);
+            const token = await fetchCSRF();
+            const finalUrl = params.url || (endpoint.startsWith("http") ? endpoint : apiUrl(endpoint));
+            const res = await performFetch(finalUrl, params.method || "GET", token, params.body, params.headers, { ...optionsRef.current, ...params }, 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, apiUrlRef.current);
-                    lastStatus = res.status;
-                }
-            }
-            const parsed = await parseResponse(res, parseAs);
+            const parsed = await parseResponse(res, params.parseAs || "auto");
             if (!res.ok)
                 throw new Error(parsed?.message || res.statusText);
+            if (debug)
+                console.log(`[useFetch] [${endpoint}] ✅ Success`);
             safeSet(() => ({ data: parsed, status: res.status }));
             return parsed;
         }
         catch (err) {
             if (err.name !== "AbortError") {
-                safeSet(() => ({ error: err.message, status: lastStatus }));
+                const msg = err.message || "Network error";
+                safeSet(() => ({ error: msg, status: lastStatus }));
                 if (onError)
-                    onError(err.message, lastStatus);
+                    onError(msg, lastStatus);
                 throw err;
             }
         }
@@ -120,9 +71,7 @@ export const useFetch = (endpoint, baseOptions = {}) => {
             safeSet(() => ({ loading: false }));
             isRequestingRef.current = false;
         }
-    }, 
-    // apiUrl REMOVED specific dependency to stop context-based invalidations
-    [endpoint, fetchCSRF, clearCsrf, safeSet, onError, debug]);
+    }, [endpoint, fetchCSRF, apiUrl, onError, debug, safeSet]);
     useEffect(() => {
         mounted.current = true;
         return () => {
@@ -130,9 +79,11 @@ export const useFetch = (endpoint, baseOptions = {}) => {
             abortRef.current?.abort();
         };
     }, []);
-    const resolvedUrl = useMemo(() => (endpoint.startsWith("http") ? endpoint : apiUrl(endpoint)), [endpoint, apiUrl]);
-    // methods is now stable across renders because request is stable
-    const methods = useMemo(() => createApiMethods({ request, baseUrl: resolvedUrl, safeSet }), [request, resolvedUrl, safeSet]);
+    const methods = useMemo(() => createApiMethods({
+        request,
+        baseUrl: endpoint.startsWith("http") ? endpoint : apiUrl(endpoint),
+        safeSet,
+    }), [request, endpoint, apiUrl, safeSet]);
     return useMemo(() => ({
         state,
         isLoading: state.loading,

package/package.json

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