@kawaiininja/fetch 1.0.38 → 1.0.40

package/dist/context/ApiContext.d.ts

@@ -16,7 +16,7 @@ export interface ApiContextValue {
     debug: boolean;
 }
 export declare const ApiContext: React.Context<ApiContextValue | null>;
-export declare function ApiProvider({ config, children }: {
+export declare function ApiProvider({ config, children, }: {
     config: ApiConfig;
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/context/ApiContext.js

@@ -1,16 +1,20 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useEffect, useMemo, useRef } 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);
-export function ApiProvider({ config, children }) {
+export function ApiProvider({ config, children, }) {
     const configRef = useRef(config);
     useEffect(() => {
         configRef.current = config;
     }, [config]);
     const apiUrl = useCallback((path) => {
-        const base = configRef.current.baseUrl;
-        if (path.startsWith("http"))
+        if (!path)
+            return configRef.current.baseUrl;
+        if (path.startsWith("http://") || path.startsWith("https://"))
             return path;
+        const base = configRef.current.baseUrl;
         const cleanBase = base.endsWith("/") ? base.slice(0, -1) : base;
         const cleanPath = path.startsWith("/") ? path : `/${path}`;
         return `${cleanBase}${cleanPath}`;

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

@@ -0,0 +1,10 @@
+type CacheEntry = {
+    data: any;
+    timestamp: number;
+    promise?: Promise<any>;
+};
+export declare const getCache: (key: string) => CacheEntry | undefined;
+export declare const setCache: (key: string, data: any, promise?: Promise<any>) => void;
+export declare const isStale: (key: string, staleTime?: number) => boolean;
+export declare const clearCache: () => void;
+export {};

package/dist/hooks/useFetch.cache.js

@@ -0,0 +1,16 @@
+const globalCache = new Map();
+export const getCache = (key) => globalCache.get(key);
+export const setCache = (key, data, promise) => {
+    globalCache.set(key, {
+        data,
+        timestamp: Date.now(),
+        promise,
+    });
+};
+export const isStale = (key, staleTime = 300000) => {
+    const entry = globalCache.get(key);
+    if (!entry)
+        return true;
+    return Date.now() - entry.timestamp > staleTime;
+};
+export const clearCache = () => globalCache.clear();

package/dist/hooks/useFetch.d.ts

@@ -1,2 +1,10 @@
+import { RequestOptions } from "./types";
 import { ApiSurface } from "./utils";
-export declare const useFetch: <T = any>(endpoint: string, baseOptions?: any) => ApiSurface<T>;
+export interface SSSOptions extends RequestOptions {
+    swr?: boolean;
+    revalidateOnFocus?: boolean;
+    refreshInterval?: number;
+    dedupeKey?: string;
+    staleTime?: number;
+}
+export declare const useFetch: <T = any>(endpoint: string, baseOptions?: SSSOptions) => ApiSurface<T>;

package/dist/hooks/useFetch.js

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useApiConfig } from "./useApiConfig";
 import { useCsrf } from "./useCsrf";
+import { getCache, isStale, setCache } from "./useFetch.cache";
 import { parseResponse, performFetch } from "./useFetch.executor";
 import { createApiMethods } from "./utils";
 export const useFetch = (endpoint, baseOptions = {}) => {
@@ -8,58 +9,98 @@ export const useFetch = (endpoint, baseOptions = {}) => {
     const { fetchCSRF } = useCsrf();
     const abortRef = useRef(new AbortController());
     const mounted = useRef(true);
-    // 🛡️ LOCK IDENTITY: Ignore baseOptions identity shifts
-    const optionsRef = useRef(baseOptions);
-    useEffect(() => {
-        optionsRef.current = baseOptions;
-    }, [JSON.stringify(baseOptions)]);
+    const cacheKey = useMemo(() => baseOptions.dedupeKey || endpoint, [endpoint, baseOptions.dedupeKey]);
+    const cached = getCache(cacheKey);
     const [state, setState] = useState({
-        data: null,
-        loading: false,
+        data: cached?.data || null,
+        loading: !cached?.data,
         error: null,
         status: null,
     });
     const safeSet = useCallback((fn) => {
         if (!mounted.current)
             return;
-        // 🚀 STACK FLATTENER: setTimeout(0) physically clears the memory stack
         setTimeout(() => {
             if (mounted.current)
                 setState((prev) => ({ ...prev, ...fn(prev) }));
         }, 0);
     }, []);
     const request = useCallback(async (params = {}) => {
-        if (debug)
-            console.log(`[API] Starting: ${endpoint}`);
-        safeSet(() => ({ loading: true, error: null }));
-        try {
-            const token = await fetchCSRF();
-            let finalUrl = params.url || endpoint;
-            if (!finalUrl.startsWith("http")) {
-                finalUrl = apiUrl(finalUrl);
+        const isRead = !params.method || params.method === "GET";
+        const currentCache = getCache(cacheKey);
+        if (isRead && currentCache?.promise)
+            return currentCache.promise;
+        if (!currentCache?.data)
+            safeSet(() => ({ loading: true, error: null }));
+        const execution = (async () => {
+            try {
+                const token = await fetchCSRF();
+                const finalUrl = apiUrl(params.url || endpoint);
+                const res = await performFetch(finalUrl, params.method || "GET", token, params.body, params.headers, { ...baseOptions, ...params }, debug, abortRef.current.signal, apiUrl);
+                const parsed = await parseResponse(res, params.parseAs || "auto");
+                if (!res.ok)
+                    throw new Error(parsed?.message || res.statusText);
+                if (isRead)
+                    setCache(cacheKey, parsed);
+                safeSet(() => ({ data: parsed, status: res.status, loading: false }));
+                return parsed;
             }
-            const res = await performFetch(finalUrl, params.method || "GET", token, params.body, params.headers, { ...optionsRef.current, ...params }, debug, abortRef.current.signal, apiUrl);
-            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: null }));
-                if (onError)
-                    onError(msg, null);
-                throw err;
+            catch (err) {
+                if (err.name !== "AbortError") {
+                    const msg = err.message || "Network error";
+                    safeSet(() => ({ error: msg, status: null, loading: false }));
+                    if (onError)
+                        onError(msg, null);
+                    throw err;
+                }
+            }
+            finally {
+                if (isRead) {
+                    const entry = getCache(cacheKey);
+                    if (entry)
+                        entry.promise = undefined;
+                }
             }
+        })();
+        if (isRead) {
+            const entry = getCache(cacheKey);
+            if (entry)
+                entry.promise = execution;
+        }
+        return execution;
+    }, [
+        endpoint,
+        cacheKey,
+        fetchCSRF,
+        apiUrl,
+        onError,
+        debug,
+        safeSet,
+        baseOptions,
+    ]);
+    useEffect(() => {
+        if (baseOptions.swr &&
+            cached?.data &&
+            isStale(cacheKey, baseOptions.staleTime)) {
+            request();
         }
-        finally {
-            safeSet(() => ({ loading: false }));
+        else if (!cached?.data) {
+            request();
         }
-    }, [endpoint, fetchCSRF, apiUrl, onError, debug, safeSet]);
+    }, []);
+    useEffect(() => {
+        if (!baseOptions.revalidateOnFocus)
+            return;
+        const onFocus = () => request();
+        window.addEventListener("focus", onFocus);
+        return () => window.removeEventListener("focus", onFocus);
+    }, [request, baseOptions.revalidateOnFocus]);
+    useEffect(() => {
+        if (!baseOptions.refreshInterval)
+            return;
+        const timer = setInterval(() => request(), baseOptions.refreshInterval);
+        return () => clearInterval(timer);
+    }, [request, baseOptions.refreshInterval]);
     useEffect(() => {
         mounted.current = true;
         return () => {
@@ -69,7 +110,7 @@ export const useFetch = (endpoint, baseOptions = {}) => {
     }, []);
     const methods = useMemo(() => createApiMethods({
         request,
-        baseUrl: endpoint.startsWith("http") ? endpoint : apiUrl(endpoint),
+        baseUrl: apiUrl(endpoint),
         safeSet,
     }), [request, endpoint, apiUrl, safeSet]);
     return useMemo(() => ({

package/dist/hooks/utils.d.ts

@@ -1,7 +1,4 @@
 import { FetchState, RequestOptions } from "./types";
-/**
- * API surface interface with all request methods
- */
 export interface ApiSurface<T = any> {
     state: FetchState<T>;
     isLoading: boolean;
@@ -21,18 +18,12 @@ export interface ApiSurface<T = any> {
     blob: (config?: RequestOptions) => Promise<Blob | undefined>;
     upload: <R = T>(formData: FormData, config?: RequestOptions) => Promise<R | undefined>;
 }
-/**
- * Parameters for creating API surface
- */
 interface CreateApiSurfaceParams<T> {
     state: FetchState<T>;
     request: <R = T>(options?: RequestOptions) => Promise<R | undefined>;
     baseUrl: string;
     safeSet: (fn: (prev: FetchState<T>) => Partial<FetchState<T>>) => void;
 }
-/**
- * Helper to construct the STABLE methods of the API surface.
- */
 export declare const createApiMethods: <T = any>({ request, baseUrl, safeSet, }: Omit<CreateApiSurfaceParams<T>, "state">) => {
     request: <R = T>(options?: RequestOptions) => Promise<R | undefined>;
     refetch: () => Promise<T | undefined>;
@@ -48,8 +39,5 @@ export declare const createApiMethods: <T = any>({ request, baseUrl, safeSet, }:
     blob: (config?: RequestOptions) => Promise<Blob | undefined>;
     upload: <R_4 = T>(formData: FormData, config?: RequestOptions) => Promise<R_4 | undefined>;
 };
-/**
- * Helper to construct the API surface object.
- */
 export declare const createApiSurface: <T = any>({ state, request, baseUrl, safeSet, }: CreateApiSurfaceParams<T>) => ApiSurface<T>;
 export {};

package/dist/hooks/utils.js

@@ -1,18 +1,15 @@
-/**
- * Helper to construct the STABLE methods of the API surface.
- */
+import { useApiConfig } from "./useApiConfig";
 export const createApiMethods = ({ request, baseUrl, safeSet, }) => {
-    // little helper for JSON methods
+    const { apiUrl } = useApiConfig();
     const withJsonBody = (data) => ({
         body: data != null ? JSON.stringify(data) : undefined,
         headers: { "Content-Type": "application/json" },
         parseAs: "json",
     });
+    const resolve = (path) => (path ? apiUrl(path) : baseUrl);
     return {
-        // 🔁 core
         request,
         refetch: () => request({ url: baseUrl }),
-        // 🎯 data helpers
         setData: (value) => {
             safeSet((prev) => ({
                 data: (typeof value === "function"
@@ -28,83 +25,61 @@ export const createApiMethods = ({ request, baseUrl, safeSet, }) => {
                     : partial),
             },
         })),
-        // 🗡 CRUD methods
-        get: (config = {}) => request({ ...config, url: config.url || baseUrl, method: "GET" }),
+        get: (config = {}) => request({ ...config, url: resolve(config.url), method: "GET" }),
         post: (data, config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: "POST",
             ...withJsonBody(data),
-            headers: {
-                ...(config.headers || {}),
-                "Content-Type": "application/json",
-            },
         }),
         put: (data, config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: "PUT",
             ...withJsonBody(data),
-            headers: {
-                ...(config.headers || {}),
-                "Content-Type": "application/json",
-            },
         }),
         patch: (data, config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: "PATCH",
             ...withJsonBody(data),
-            headers: {
-                ...(config.headers || {}),
-                "Content-Type": "application/json",
-            },
         }),
         delete: (config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: "DELETE",
             parseAs: config.parseAs || "json",
         }),
-        // 🎭 type-focused helpers
         json: (data, config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: config.method || "POST",
             ...withJsonBody(data),
-            headers: {
-                ...(config.headers || {}),
-                "Content-Type": "application/json",
-            },
         }),
         text: (config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: config.method || "GET",
             parseAs: "text",
         }),
         blob: (config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
+            url: resolve(config.url),
             method: config.method || "GET",
             parseAs: "blob",
         }),
         upload: (formData, config = {}) => request({
             ...config,
-            url: config.url || baseUrl,
-            method: config.method || "POST",
+            url: resolve(config.url),
+            method: "POST",
             body: formData,
             parseAs: config.parseAs || "json",
         }),
     };
 };
-/**
- * Helper to construct the API surface object.
- */
 export const createApiSurface = ({ state, request, baseUrl, safeSet, }) => {
     const methods = createApiMethods({ request, baseUrl, safeSet });
     return {
-        // 🔍 state
         state,
         isLoading: state.loading,
         isError: !!state.error,

package/package.json

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