@kawaiininja/fetch 1.0.39 → 1.0.41

package/README.md

@@ -4,17 +4,20 @@ A production-grade, hybrid-native HTTP client designed for the Onyx Framework.
 
 **Rating: S-Tier Utility 🏆**
 
-This package automates enterprise-grade security, CSRF handling, and platform detection (Web vs. Native Mobile), allowing you to focus on building features rather than handling HTTP boilerplate.
+This package automates enterprise-grade security, CSRF handling, and platform detection (Web vs. Native Mobile), allowing you to focus on building features rather than handling HTTP boilerplate. It is optimized for high-performance React applications with built-in caching and retry logic.
 
 ## 🚀 Features
 
 - **Hybrid Intelligence**: Automatically detects if running on Web or Native Mobile (Capacitor).
+- **🛡️ Session Memory Vault**: High-performance token caching for native apps that avoids expensive SecureStorage calls on every request.
 - **Pro Security**:
-  - **Native**: Uses `SecureStoragePlugin` for token management.
-  - **Web**: Uses `HttpOnly` cookies + Auto-CSRF token rotation.
-- **Smart Retries**: Automatically handles `403 CSRF` errors by fetching a new token and retrying the request.
-- **Optimistic Updates**: Update your UI instantly before the server responds.
-- **Type-Safe**: Full TypeScript support, but works efficiently in JS too.
+  - **Native**: Uses `SecureStoragePlugin` (with localStorage fallback) for secure token management.
+  - **Web**: Uses `HttpOnly` cookies + Automatic CSRF token rotation.
+- **⚡ Strict Reliability**:
+  - **3s Execution Deadline**: Requests that take too long are automatically aborted to prevent UI hangs.
+  - **3x Auto-Retries**: Transparently retries failed network requests before surfacing an error.
+- **📦 Caching & SWR**: Built-in support for Stale-While-Revalidate, custom dedupe keys, and focus-based revalidation.
+- **Type-Safe & Efficient**: Optimized for both TypeScript and standard JavaScript.
 
 ---
 
@@ -28,9 +31,13 @@ import { ApiProvider } from "@kawaiininja/fetch";
 
 const apiConfig = {
   baseUrl: "https://api.myapp.com",
-  version: "v1",
+  version: "v1", // Appends /v1 to all requests
+  debug: true, // Enables detailed logging for network and security flows
   // Optional: Global error handler (e.g., for Toast notifications)
-  onError: (msg, status) => console.error(`[API Error ${status}]: ${msg}`),
+  onError: (msg, status) => {
+    // Trigger global snackbar/toast here
+    console.error(`[API Error ${status}]: ${msg}`);
+  },
 };
 
 export default function App() {
@@ -44,129 +51,142 @@ export default function App() {
 
 ---
 
-## 📖 Usage Patterns (Efficient JS)
+## 📖 Usage Patterns
 
-### 1. Lazy Action (Forms & Buttons)
+### 1. Simple Data Fetching (SWR Style)
 
-Best for login forms, submitting data, or manual triggers. No need for `useState` or `try/catch` boilerplate.
+By default, `useFetch` can handle loading states and caching automatically.
 
 ```jsx
 import { useFetch } from "@kawaiininja/fetch";
 
-export const LoginForm = () => {
-  // Extract helpers directly
-  const { post, isLoading, error } = useFetch("/auth/login");
+export const Profile = () => {
+  const { data, isLoading, error, get } = useFetch("/user/me", {
+    swr: true, // Return cached data immediately, then fetch updates
+    staleTime: 60000, // Consider data fresh for 1 minute
+    revalidateOnFocus: true, // Refetch when user switches tabs back
+  });
 
-  const handleLogin = async (e) => {
-    e.preventDefault();
-    const formData = new FormData(e.target);
-    const payload = Object.fromEntries(formData);
-
-    // ✅ Efficient: helper handles JSON stringify, headers, and loading state
-    const user = await post(payload);
-
-    if (user) {
-      console.log("Welcome", user.name);
-      // Redirect or update context here
-    }
-  };
+  if (isLoading && !data) return <p>Loading...</p>;
 
   return (
-    <form onSubmit={handleLogin}>
-      {error && <div className="error-banner">{error}</div>}
-
-      <input name="email" type="email" placeholder="Email" />
-      <input name="password" type="password" placeholder="Password" />
-
-      <button disabled={isLoading}>
-        {isLoading ? "Logging in..." : "Log In"}
-      </button>
-    </form>
+    <div>
+      <h1>{data?.name}</h1>
+      <button onClick={() => get()}>Refresh Profile</button>
+    </div>
   );
 };
 ```
 
-### 2. Optimistic Updates (Instant UX)
+### 2. Actions (POST/PUT/PATCH/DELETE)
 
-Make your app feel zero-latency by updating the local data _before_ the server responds.
+The hook returns simple helper methods that handle JSON stringification and loading states for you.
 
 ```jsx
-const UserProfile = () => {
-  // 'data' is your state, 'setData' lets you modify it instantly
-  const { data, setData, patch } = useFetch("/user/me");
-
-  const updateName = async (newName) => {
-    // 1. Instant UI update (Optimistic)
-    // We assume it will succeed to make it feel snappy
-    setData((prev) => ({ ...prev, name: newName }));
-
-    // 2. Send request in background
-    // If it fails, the error state will update automatically and revert (if you handle it)
-    await patch({ name: newName });
+const LoginForm = () => {
+  const { post, isLoading } = useFetch("/auth/login");
+
+  const onSubmit = async (payload) => {
+    // helpers return the parsed data directly
+    const user = await post(payload);
+    if (user) login(user);
   };
 
   return (
-    <div>
-      <h1>Hello, {data?.name || "Guest"}</h1>
-      <button onClick={() => updateName("Vinay")}>Update Name</button>
-    </div>
+    <button onClick={() => onSubmit({ user: "..." })} disabled={isLoading}>
+      {isLoading ? "Logging in..." : "Submit"}
+    </button>
   );
 };
 ```
 
-### 3. Fetch on Load (Page Data)
+### 3. Advanced Request Options
 
-For standard "load data when page opens" behavior, simply pair with `useEffect`.
+You can override defaults or pass extra headers/parameters on a per-call basis. Every method (`get`, `post`, `request`, etc.) accepts an options object.
 
 ```jsx
-import { useEffect } from "react";
-import { useFetch } from "@kawaiininja/fetch";
+const { get, post, upload } = useFetch("/data");
+
+// Overriding URL or passing custom headers
+get({
+  url: "/custom-endpoint",
+  headers: { "X-Custom-Header": "value" },
+  timeout: 5000, // Override default 3s timeout
+});
+
+// Handling non-JSON responses
+const textData = await get({ parseAs: "text" });
+
+// File Uploads
+const handleUpload = (file) => {
+  const fd = new FormData();
+  fd.append("file", file);
+  upload(fd);
+};
+```
 
-export const Dashboard = () => {
-  // 'get' is the trigger function
-  const { data, isLoading, get } = useFetch("/dashboard");
+### 4. Reactive Search (Watcher Pattern)
 
-  useEffect(() => {
-    // Trigger the fetch when component mounts
-    get();
-  }, []); // Empty array ensures it only runs once
+Trigger a fetch whenever a specific dependency changes.
 
-  if (isLoading) return <div>Loading...</div>;
+```jsx
+const SearchResult = ({ query }) => {
+  const { data, get } = useFetch("/search", { enabled: false });
 
-  return (
-    <div>
-      <h1>Dashboard Stats</h1>
-      <pre>{JSON.stringify(data, null, 2)}</pre>
-    </div>
-  );
+  useEffect(() => {
+    if (query) get({ url: `/search?q=${query}` });
+  }, [query]);
+
+  return <List items={data} />;
 };
 ```
 
-### 4. Reactive Fetch (Search & Filters)
+---
 
-Trigger a fetch automatically whenever a variable changes (like a filter button or search bar).
+## ⚙️ Configuration Reference
 
-```jsx
-import { useEffect, useState } from "react";
-import { useFetch } from "@kawaiininja/fetch";
+### `useFetch(endpoint, options)`
 
-export const FilterList = () => {
-  const [filter, setFilter] = useState("all");
-  const [search, setSearch] = useState("");
-  const { data, get } = useFetch("/items");
+Initial options configured when calling the hook:
 
-  // ✅ The "Watcher" Pattern
-  useEffect(() => {
-    // Overrides the URL with new params whenever dependencies change
-    get({ url: `/items?status=${filter}&q=${search}` });
-  }, [filter, search]); // 👈 DEPENDENCY ARRAY controls the trigger
+| Option              | Type      | Default    | Description                                       |
+| :------------------ | :-------- | :--------- | :------------------------------------------------ |
+| `enabled`           | `boolean` | `true`     | Set to false to prevent automatic fetch on mount. |
+| `swr`               | `boolean` | `false`    | Enable Stale-While-Revalidate caching.            |
+| `staleTime`         | `number`  | `300000`   | MS until cache is considered stale (5 mins).      |
+| `revalidateOnFocus` | `boolean` | `false`    | Refetch data when window gains focus.             |
+| `refreshInterval`   | `number`  | `0`        | Auto-refresh data every X milliseconds.           |
+| `dedupeKey`         | `string`  | `endpoint` | Custom key for caching.                           |
 
-  return (
-    <div>
-      <button onClick={() => setFilter("active")}>Active</button>
-      <input onChange={(e) => setSearch(e.target.value)} />
-      <List items={data} />
-    </div>
-  );
-};
-```
+### Per-Request Options (passed to `get`, `post`, etc.)
+
+| Option    | Type     | Default    | Description                                             |
+| :-------- | :------- | :--------- | :------------------------------------------------------ |
+| `url`     | `string` | `endpoint` | Override the default endpoint.                          |
+| `method`  | `string` | `"GET"`    | HTTP Method.                                            |
+| `headers` | `object` | `{}`       | Custom headers.                                         |
+| `timeout` | `number` | `3000`     | Per-request timeout limit.                              |
+| `retries` | `number` | `3`        | Number of times to retry on network failure.            |
+| `parseAs` | `string` | `"auto"`   | How to parse response (`json`, `text`, `blob`, `auto`). |
+
+### Returned Surface
+
+- `data`: The parsed response body.
+- `isLoading`: Boolean loading state.
+- `error`: Error message string (if any).
+- `get(options)`, `post(body, options)`, `put(body, options)`, `patch(body, options)`, `del(options)`: HTTP methods.
+- `upload(formData, options)`: Dedicated multipart/form-data helper.
+- `text(options)` / `blob(options)`: Shortcuts for formatted responses.
+- `setData(updater)`: Manually update `data` state.
+- `updateData(partial)`: Merge partial updates into `data`.
+
+---
+
+## 🛡️ Security Logic
+
+1. **Native**: Checks `SecureStorage` -> `localStorage`. If found, injects `Authorization: Bearer <token>` and `X-Session-ID: <id>`. CSRF is skipped.
+2. **Web**: Fetches CSRF token from `/auth/csrf-token` on first boot. Injects `X-CSRF-Token` in all internal requests. Automatically refreshes token on 403 errors.
+
+---
+
+&copy; 2024 KawaiiNinja. Built for High-Performance Onyx Apps.

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,11 @@
+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;
+    enabled?: boolean;
+}
+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,97 @@ 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 { enabled = true, swr = false, staleTime = 300000 } = 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: enabled && !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;
         }
-        finally {
-            safeSet(() => ({ loading: false }));
+        return execution;
+    }, [
+        endpoint,
+        cacheKey,
+        fetchCSRF,
+        apiUrl,
+        onError,
+        debug,
+        safeSet,
+        baseOptions,
+    ]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const shouldFetch = !cached?.data || (swr && isStale(cacheKey, staleTime));
+        if (shouldFetch) {
+            request();
         }
-    }, [endpoint, fetchCSRF, apiUrl, onError, debug, safeSet]);
+    }, [enabled, cacheKey, swr, staleTime]);
+    useEffect(() => {
+        if (!baseOptions.revalidateOnFocus || !enabled)
+            return;
+        const onFocus = () => request();
+        window.addEventListener("focus", onFocus);
+        return () => window.removeEventListener("focus", onFocus);
+    }, [request, baseOptions.revalidateOnFocus, enabled]);
+    useEffect(() => {
+        if (!baseOptions.refreshInterval || !enabled)
+            return;
+        const timer = setInterval(() => request(), baseOptions.refreshInterval);
+        return () => clearInterval(timer);
+    }, [request, baseOptions.refreshInterval, enabled]);
     useEffect(() => {
         mounted.current = true;
         return () => {
@@ -69,7 +109,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,19 +18,13 @@ 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">) => {
+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>;
     setData: (value: T | null | ((prev: T | null) => T | null)) => void;
@@ -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 declare const createApiSurface: <T = any>({ state, request, baseUrl, safeSet, }: CreateApiSurfaceParams<T>) => ApiSurface<T>;
 export {};

package/dist/hooks/utils.js

@@ -1,108 +1,85 @@
 import { useApiConfig } from "./useApiConfig";
-/**
- * Helper to construct the STABLE methods of the API surface.
- */
-export const createApiMethods = ({ request, baseUrl, safeSet }) => {
-    // little helper for JSON methods
+export const createApiMethods = ({ request, baseUrl, safeSet, }) => {
+    const { apiUrl } = useApiConfig();
     const withJsonBody = (data) => ({
         body: data != null ? JSON.stringify(data) : undefined,
         headers: { "Content-Type": "application/json" },
         parseAs: "json",
     });
-    const { apiUrl } = useApiConfig();
+    const resolve = (path) => (path ? apiUrl(path) : baseUrl);
     return {
-        // 🔁 core
         request,
         refetch: () => request({ url: baseUrl }),
-        // 🎯 data helpers
         setData: (value) => {
             safeSet((prev) => ({
-                data: (typeof value === "function" ? value(prev.data) : value),
+                data: (typeof value === "function"
+                    ? value(prev.data)
+                    : value),
             }));
         },
         updateData: (partial) => safeSet((prev) => ({
             data: {
                 ...prev.data,
-                ...(typeof partial === "function" ? partial(prev.data) : partial),
+                ...(typeof partial === "function"
+                    ? partial(prev.data)
+                    : 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: apiUrl(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 }) => {
+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.39",
+    "version": "1.0.41",
     "description": "Core fetch utility for Onyx Framework",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",