@kawaiininja/fetch 1.0.28 → 1.0.29

package/dist/context/ApiContext.d.ts

@@ -15,13 +15,8 @@ export interface ApiContextValue {
     onError?: (error: string, status: number | null) => void;
     debug: boolean;
 }
-export interface ApiProviderProps {
+export declare const ApiContext: React.Context<ApiContextValue | null>;
+export declare function ApiProvider({ config, children }: {
     config: ApiConfig;
     children: React.ReactNode;
-}
-export declare const ApiContext: React.Context<ApiContextValue | null>;
-/**
- * ApiProvider
- * 🛡️ GOD-LEVEL STABILITY: Decouples helper identity from render cycles.
- */
-export declare function ApiProvider({ config, children }: ApiProviderProps): import("react/jsx-runtime").JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/context/ApiContext.js

@@ -1,41 +1,26 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useMemo, useRef, useEffect } from "react";
-export const INTERNAL_HEADER = {
-    "x-internal-service": "zevrinix-main",
-};
+import { createContext, useCallback, useEffect, useMemo, useRef } from "react";
+export const INTERNAL_HEADER = { "x-internal-service": "zevrinix-main" };
 export const ApiContext = createContext(null);
-/**
- * ApiProvider
- * 🛡️ GOD-LEVEL STABILITY: Decouples helper identity from render cycles.
- */
 export function ApiProvider({ config, children }) {
-    const baseUrlRef = useRef(config?.baseUrl || "");
-    const onErrorRef = useRef(config?.onError);
+    const configRef = useRef(config);
     useEffect(() => {
-        baseUrlRef.current = config?.baseUrl || "";
-        onErrorRef.current = config?.onError;
-    }, [config?.baseUrl, config?.onError]);
-    /**
-     * 🛡️ PERMANENT IDENTITY URL HELPER
-     * Identity is fixed for the life of the App. No downstream loops possible.
-     */
+        configRef.current = config;
+    }, [config]);
     const apiUrl = useCallback((path) => {
-        const base = baseUrlRef.current;
+        const base = configRef.current.baseUrl;
         if (path.startsWith("http"))
             return path;
         const cleanBase = base.endsWith("/") ? base.slice(0, -1) : base;
         const cleanPath = path.startsWith("/") ? path : `/${path}`;
         return `${cleanBase}${cleanPath}`;
     }, []);
-    const baseUrl = config?.baseUrl || "";
-    const version = config?.version || "v1";
-    const debug = !!config?.debug;
     const value = useMemo(() => ({
-        baseUrl,
-        version,
-        debug,
+        baseUrl: config.baseUrl,
+        version: config.version || "v1",
+        debug: !!config.debug,
         apiUrl,
-        onError: (err, status) => onErrorRef.current?.(err, status),
-    }), [baseUrl, version, debug, apiUrl]);
+        onError: (e, s) => configRef.current.onError?.(e, s),
+    }), [config.baseUrl, config.version, config.debug, apiUrl]);
     return _jsx(ApiContext.Provider, { value: value, children: children });
 }

package/dist/hooks/useFetch.d.ts

@@ -1,7 +1,2 @@
 import { ApiSurface } from "./utils";
-export { clearNativeAuthVault } from "./useFetch.vault";
-/**
- * useFetch Hook
- * 🛡️ STACK PROTECTION: Macro-task Flattening + Identity Locking
- */
 export declare const useFetch: <T = any>(endpoint: string, baseOptions?: any) => ApiSurface<T>;

package/dist/hooks/useFetch.executor.d.ts

@@ -1,6 +1,2 @@
-/**
- * 🛡️ CORE FETCH EXECUTOR
- * Handles the actual network request with retries and timeout.
- */
 export declare const performFetch: (url: string, method: string, token: string, body?: BodyInit, headers?: HeadersInit, rest?: RequestInit, debug?: boolean, abortSignal?: AbortSignal, apiUrl?: (path: string) => string) => Promise<Response>;
 export declare const parseResponse: (res: Response, parseAs: string) => Promise<any>;

package/dist/hooks/useFetch.executor.js

@@ -1,10 +1,9 @@
 import { INTERNAL_HEADER } from "../context/ApiContext";
 import { isNative } from "./platform";
 import { initializeVault, nativeAuthVault } from "./useFetch.vault";
-/**
- * 🛡️ CORE FETCH EXECUTOR
- * Handles the actual network request with retries and timeout.
- */
+const TIMEOUT_MS = 15000;
+const RETRY_DELAY_MS = 3000;
+const MAX_ATTEMPTS = 3;
 export const performFetch = async (url, method, token, body, headers, rest, debug, abortSignal, apiUrl) => {
     const _isNative = isNative();
     const isInternal = url.startsWith("/") || (apiUrl && url.startsWith(apiUrl(""))) || false;
@@ -12,43 +11,31 @@ export const performFetch = async (url, method, token, body, headers, rest, debu
         ...(headers || {}),
         ...INTERNAL_HEADER,
     };
-    // 🔒 NATIVE SECURITY
     if (_isNative && isInternal) {
         await initializeVault(debug);
-        const authToken = nativeAuthVault.token;
-        const sessionId = nativeAuthVault.sessionId;
-        if (authToken)
-            headersConfig["Authorization"] = `Bearer ${authToken}`;
-        if (sessionId)
-            headersConfig["X-Session-ID"] = sessionId;
+        if (nativeAuthVault.token)
+            headersConfig["Authorization"] = `Bearer ${nativeAuthVault.token}`;
+        if (nativeAuthVault.sessionId)
+            headersConfig["X-Session-ID"] = nativeAuthVault.sessionId;
     }
-    // 🔒 WEB SECURITY
-    if (!_isNative && isInternal && token) {
+    if (!_isNative && isInternal && token)
         headersConfig["X-CSRF-Token"] = token;
-    }
-    return executeWithRetry(url, method, headersConfig, body, rest, debug, abortSignal);
-};
-/**
- * Executes a fetch request with 3 retry attempts.
- */
-async function executeWithRetry(url, method, headers, body, rest, debug, abortSignal) {
-    let attempt = 0;
-    const maxAttempts = 3;
-    let lastError = null;
-    while (attempt < maxAttempts) {
-        attempt++;
-        const TIMEOUT_MS = 15000;
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
-        // Link to external abort signal if provided
         const onAbort = () => controller.abort();
         if (abortSignal)
             abortSignal.addEventListener("abort", onAbort);
         try {
-            const response = await Promise.race([
-                fetch(url, { ...rest, method, signal: controller.signal, credentials: "include", headers, body }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout of ${TIMEOUT_MS}ms exceeded`)), TIMEOUT_MS)),
-            ]);
+            const response = await fetch(url, {
+                ...rest,
+                method,
+                signal: controller.signal,
+                credentials: "include",
+                headers: headersConfig,
+                body,
+            });
             clearTimeout(timeoutId);
             if (abortSignal)
                 abortSignal.removeEventListener("abort", onAbort);
@@ -59,26 +46,22 @@ async function executeWithRetry(url, method, headers, body, rest, debug, abortSi
             if (abortSignal)
                 abortSignal.removeEventListener("abort", onAbort);
             lastError = error;
-            if (error.name === "AbortError" || abortSignal?.aborted)
-                throw error;
+            if (error.name === "AbortError" || attempt === MAX_ATTEMPTS)
+                break;
             if (debug)
-                console.warn(`[useFetch] Attempt ${attempt} failed: ${error.message}.`);
-            if (attempt < maxAttempts)
-                await new Promise((r) => setTimeout(r, 1000));
+                console.warn(`[API] Attempt ${attempt} failed, retrying in 3s...`);
+            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
         }
     }
     throw lastError || new Error("Request failed after 3 attempts");
-}
+};
 export const parseResponse = async (res, parseAs) => {
     const type = res.headers.get("content-type") || "";
-    if (parseAs === "json" || (parseAs === "auto" && type.includes("application/json"))) {
+    if (parseAs === "json" || (parseAs === "auto" && type.includes("application/json")))
         return res.json();
-    }
-    else if (parseAs === "text") {
+    if (parseAs === "text")
         return res.text();
-    }
-    else if (parseAs === "blob") {
+    if (parseAs === "blob")
         return res.blob();
-    }
-    return res.text();
+    return res;
 };

package/dist/hooks/useFetch.js

@@ -3,74 +3,57 @@ import { useApiConfig } from "./useApiConfig";
 import { useCsrf } from "./useCsrf";
 import { parseResponse, performFetch } from "./useFetch.executor";
 import { createApiMethods } from "./utils";
-export { clearNativeAuthVault } from "./useFetch.vault";
-/**
- * useFetch Hook
- * 🛡️ STACK PROTECTION: Macro-task Flattening + Identity Locking
- */
 export const useFetch = (endpoint, baseOptions = {}) => {
     const { apiUrl, onError, debug } = useApiConfig();
     const { fetchCSRF } = useCsrf();
     const abortRef = useRef(new AbortController());
     const mounted = useRef(true);
     const isRequestingRef = useRef(false);
-    // 🔒 Hold baseOptions in a Ref to prevent render-cycle re-triggers
-    // Removed Math.random() fallback which was causing infinite loops.
+    // 🛡️ LOCK IDENTITY: Ignore baseOptions identity shifts
     const optionsRef = useRef(baseOptions);
-    const optionsHash = useMemo(() => {
-        try {
-            return JSON.stringify(baseOptions);
-        }
-        catch {
-            return endpoint;
-        }
-    }, [baseOptions, endpoint]);
     useEffect(() => {
         optionsRef.current = baseOptions;
-    }, [optionsHash]);
+    }, [JSON.stringify(baseOptions)]);
     const [state, setState] = useState({
         data: null,
         loading: false,
         error: null,
         status: null,
     });
-    /**
-     * 🛡️ MACRO-TASK SETTER
-     * Using setTimeout(0) forces a physical stack clear by the JS event loop.
-     * This stops the "Stack Pile" effect in production APKs.
-     */
     const safeSet = useCallback((fn) => {
         if (!mounted.current)
             return;
+        // 🚀 STACK FLATTENER: setTimeout(0) physically clears the memory stack
         setTimeout(() => {
-            if (mounted.current) {
+            if (mounted.current)
                 setState((prev) => ({ ...prev, ...fn(prev) }));
-            }
         }, 0);
     }, []);
     const request = useCallback(async (params = {}) => {
         if (isRequestingRef.current)
             return;
         isRequestingRef.current = true;
+        if (debug)
+            console.log(`[API] Starting: ${endpoint}`);
         safeSet(() => ({ loading: true, error: null }));
-        let lastStatus = null;
         try {
             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;
             const parsed = await parseResponse(res, params.parseAs || "auto");
             if (!res.ok)
                 throw new Error(parsed?.message || res.statusText);
+            if (debug)
+                console.log(`[API] Success: ${endpoint}`);
             safeSet(() => ({ data: parsed, status: res.status }));
             return parsed;
         }
         catch (err) {
             if (err.name !== "AbortError") {
-                const msg = err.message || "Network Error";
-                safeSet(() => ({ error: msg, status: lastStatus }));
+                const msg = err.message || "Network error";
+                safeSet(() => ({ error: msg, status: null }));
                 if (onError)
-                    onError(msg, lastStatus);
+                    onError(msg, null);
                 throw err;
             }
         }
@@ -83,7 +66,7 @@ export const useFetch = (endpoint, baseOptions = {}) => {
         mounted.current = true;
         return () => {
             mounted.current = false;
-            abortRef.current?.abort();
+            abortRef.current.abort();
         };
     }, []);
     const methods = useMemo(() => createApiMethods({

package/package.json

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