katanakit-js 6.2.0 → 6.6.1

package/dist/core/services/http.service.js

@@ -1,7 +1,7 @@
 import { useTryJsonParse } from "./result.service.js";
 import { useSplitConfig } from "./utils.service.js";
-/** Module-level API registry. */
-let apis = {};
+/** Error bodies are truncated so a hostile response cannot exhaust memory. */
+const MAX_ERROR_BODY_CHARS = 32 * 1024;
 /**
  * Internal: narrows an unknown literal entry to an {@link ApiEntry}.
  *
@@ -11,28 +11,12 @@ let apis = {};
 function isApiEntry(value) {
     return typeof value === "object" && value !== null && "baseUri" in value && "endpoints" in value;
 }
-/**
- * Internal: retrieves a registered API entry or throws.
- *
- * @param apiName - The key of the API in the registry.
- * @returns The {@link ApiEntry} for the given name.
- * @throws {Error} If the API is not registered.
- */
-function getApiEntry(apiName) {
-    const api = apis[apiName];
-    if (!api) {
-        throw new Error(`[FetchApiManager] API "${apiName}" is not registered.`);
-    }
-    return api;
-}
 /**
  * Internal: reads a Response body, attempting JSON parse for JSON content types.
  *
  * @param response - The fetch Response to read.
  * @returns The parsed body or `null` for empty responses.
  */
-/** Error bodies are truncated so a hostile response cannot exhaust memory. */
-const MAX_ERROR_BODY_CHARS = 32 * 1024;
 async function readBody(response, maxChars) {
     const text = await response.text();
     if (!text)
@@ -72,7 +56,338 @@ function serializeBody(body) {
     };
 }
 /**
- * Declares the API registry in a single call — the config-file entry point.
+ * Picks the URL-building keys out of an options bag so nothing else leaks into
+ * the `RequestInit` handed to `fetch`.
+ *
+ * @param urlOptions - Legacy URL options, if any.
+ * @returns Only `params`, `query` and `ignoreDefaultQuery`, when defined.
+ */
+function pickUrl(urlOptions) {
+    if (!urlOptions)
+        return {};
+    const { params, query, ignoreDefaultQuery } = urlOptions;
+    return {
+        ...(params !== undefined && { params }),
+        ...(query !== undefined && { query }),
+        ...(ignoreDefaultQuery !== undefined && { ignoreDefaultQuery }),
+    };
+}
+/**
+ * FetchApiManager - Singleton para el registro de APIs y peticiones HTTP.
+ *
+ * Aplica el patrón Singleton: una única instancia mantiene el registro de APIs
+ * (`ApisConfig`) y centraliza la construcción de URLs y las peticiones fetch,
+ * devolviendo siempre Safe Results (nunca lanza en rutas async).
+ *
+ * @example
+ * ```ts
+ * const fetchApi = FetchApiManager.getInstance();
+ * fetchApi.useInit({ pokeapi: { baseUri: "https://pokeapi.co/api/v2", endpoints: { byId: "/pokemon/:id/" } } });
+ * const result = await fetchApi.useFetch("pokeapi", "byId", { params: { id: 25 } });
+ * ```
+ */
+export class FetchApiManager {
+    static instance;
+    /** Module-level API registry. */
+    apis = {};
+    /**
+     * Constructor privado - enforce singleton.
+     */
+    constructor() { }
+    /**
+     * Obtiene la instancia única del FetchApiManager (Singleton).
+     *
+     * @returns La instancia única de {@link FetchApiManager}.
+     */
+    static getInstance() {
+        if (!FetchApiManager.instance) {
+            FetchApiManager.instance = new FetchApiManager();
+        }
+        return FetchApiManager.instance;
+    }
+    /**
+     * Internal: retrieves a registered API entry or throws.
+     *
+     * @param apiName - The key of the API in the registry.
+     * @returns The {@link ApiEntry} for the given name.
+     * @throws {Error} If the API is not registered.
+     */
+    useGetApiEntry(apiName) {
+        const api = this.apis[apiName];
+        if (!api) {
+            throw new Error(`[FetchApiManager] API "${apiName}" is not registered.`);
+        }
+        return api;
+    }
+    /**
+     * Registers (merges) API definitions into the client registry.
+     *
+     * @param apisConfig - The API definitions to merge into the registry.
+     *
+     * @example
+     * ```ts
+     * FetchApiManager.getInstance().useInit({
+     *   pokeapi: { baseUri: "https://pokeapi.co/api/v2", endpoints: { pokemonById: "/pokemon/:id/" } },
+     * });
+     * ```
+     */
+    useInit(apisConfig) {
+        this.apis = { ...this.apis, ...apisConfig };
+    }
+    /**
+     * Returns a shallow copy of the registered APIs (safe to mutate locally).
+     *
+     * @returns A shallow copy of the current API registry.
+     */
+    useGetApis() {
+        return { ...this.apis };
+    }
+    /**
+     * Returns the URL of a registered endpoint **without calling `fetch`**.
+     *
+     * It builds the same URL {@link useFetch} would request - same registry,
+     * same `:param` substitution, same `query` merge with `defaultQueryParams`,
+     * same http(s) guard - then stops and hands you the string.
+     *
+     * @param apiName - Registered API key (from `defineApiConfig`).
+     * @param endpointName - Endpoint key inside that API.
+     * @param options - `params` fills `:placeholders`, `query` becomes the search string.
+     * @returns The fully built URL.
+     * @throws {Error} Unknown API, unknown endpoint, or a scheme that is not http(s).
+     *
+     * @example
+     * ```ts
+     * FetchApiManager.getInstance().useBuildUrl("pokeapi", "pokemonById", { params: { id: 25 } });
+     * // → "https://pokeapi.co/api/v2/pokemon/25"
+     * ```
+     *
+     * @remarks Synchronous, so it **throws** instead of returning a Safe Result -
+     * Safe Result covers fallible async work, and this never leaves the process.
+     */
+    useBuildUrl(apiName, endpointName, options = {}) {
+        const { params, query, ignoreDefaultQuery = false } = options;
+        const api = this.useGetApiEntry(apiName);
+        let path = api.endpoints?.[endpointName] ?? "";
+        if (!path) {
+            throw new Error(`[FetchApiManager] Endpoint "${endpointName}" not found in API "${apiName}".`);
+        }
+        if (params) {
+            const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            path = Object.entries(params).reduce((acc, [key, value]) => acc.replace(new RegExp(`:${escapeRegex(key)}\\b`, "g"), encodeURIComponent(String(value))), path);
+        }
+        const baseStr = api.baseUri instanceof URL ? api.baseUri.toString() : api.baseUri;
+        const baseClean = baseStr.endsWith("/") ? baseStr.slice(0, -1) : baseStr;
+        const pathClean = path.startsWith("/") ? path : `/${path}`;
+        const url = new URL(`${baseClean}${pathClean}`);
+        // Only allow http(s) to prevent SSRF and `javascript:` URLs.
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error(`[FetchApiManager] Scheme "${url.protocol}" is not allowed.`);
+        }
+        const defaultParams = ignoreDefaultQuery ? {} : (api.defaultQueryParams?.[endpointName] ?? {});
+        const mergedQuery = { ...defaultParams, ...query };
+        for (const [key, value] of Object.entries(mergedQuery)) {
+            if (value !== undefined && value !== null) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+    /**
+     * Fetches a registered endpoint and returns a Safe Result.
+     *
+     * URL options sit at the top level, next to `method`/`headers`/`body` - no
+     * nesting, same shape as `useGet` and Nuxt's `useFetch`.
+     *
+     * @param apiName - The registered API key.
+     * @param endpointName - The endpoint key within the API.
+     * @param options - Fetch options: `params`, `query`, `transform` and any `RequestInit` field.
+     * @returns A `FetchResult` with data or error. Never throws - a failing
+     *   `transform` comes back as an error result too.
+     *
+     * @example
+     * ```ts
+     * const result = await FetchApiManager.getInstance().useFetch<{ results: unknown[] }>(
+     *   "pokeapi",
+     *   "pokemons",
+     *   { method: "GET", query: { limit: 2 } },
+     * );
+     * if (result.ok) console.log(result.data.results);
+     * ```
+     */
+    async useFetch(apiName, endpointName, { params, query, ignoreDefaultQuery, urlOptions, transform, ...init } = {}) {
+        let url = "";
+        // The flat keys and the deprecated `urlOptions` nest describe the same
+        // thing; the flat form wins. `undefined` means "not given", so it must not
+        // overwrite a value coming from the legacy nest.
+        const buildOptions = { ...urlOptions };
+        if (params !== undefined)
+            buildOptions.params = params;
+        if (query !== undefined)
+            buildOptions.query = query;
+        if (ignoreDefaultQuery !== undefined)
+            buildOptions.ignoreDefaultQuery = ignoreDefaultQuery;
+        try {
+            url = this.useBuildUrl(apiName, endpointName, buildOptions);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                data: null,
+                error: {
+                    message: `Config Error: ${message}`,
+                    status: 0,
+                },
+                url,
+                status: 0,
+                ok: false,
+            };
+        }
+        try {
+            // Fail closed on redirects: the scheme allow-list only validates the
+            // initial URL, so following a 3xx could steer the request to a private
+            // host (SSRF). Callers that need redirects can pass `redirect: "follow"`.
+            const response = await fetch(url, { redirect: "error", ...init });
+            if (!response.ok) {
+                const errorDetails = await readBody(response, MAX_ERROR_BODY_CHARS);
+                return {
+                    data: null,
+                    error: {
+                        message: `HTTP Error: ${response.statusText || "Unsuccessful response"}`,
+                        status: response.status,
+                        details: errorDetails,
+                    },
+                    url: response.url || url,
+                    status: response.status,
+                    ok: false,
+                };
+            }
+            // 204 No Content and empty bodies are valid success responses.
+            const body = response.status === 204 ? null : await readBody(response);
+            let data = body;
+            if (transform) {
+                try {
+                    data = await transform(body);
+                }
+                catch (err) {
+                    // A failing transform is still a failed request - return it as a
+                    // Safe Result instead of letting it escape `useFetch`.
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        data: null,
+                        error: {
+                            message: `Transform Error: ${message}`,
+                            status: response.status,
+                        },
+                        url: response.url || url,
+                        status: response.status,
+                        ok: false,
+                    };
+                }
+            }
+            return {
+                data: data,
+                error: null,
+                url: response.url || url,
+                status: response.status,
+                ok: true,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                data: null,
+                error: {
+                    message: `Network/Client Error: ${message}`,
+                    status: 0,
+                },
+                url,
+                status: 0,
+                ok: false,
+            };
+        }
+    }
+    /**
+     * GET helper over a registered API endpoint.
+     *
+     * @param apiName - The registered API key.
+     * @param endpointName - The endpoint key within the API.
+     * @param urlOptions - Optional URL building options.
+     * @returns A `FetchResult` with data or error.
+     */
+    async useGet(apiName, endpointName, urlOptions) {
+        return this.useFetch(apiName, endpointName, {
+            method: "GET",
+            ...pickUrl(urlOptions),
+        });
+    }
+    /**
+     * POST helper over a registered API endpoint.
+     *
+     * @param apiName - The registered API key.
+     * @param endpointName - The endpoint key within the API.
+     * @param body - Optional request body (auto-serialized to JSON unless raw).
+     * @param urlOptions - Optional URL building options.
+     * @returns A `FetchResult` with data or error.
+     */
+    async usePost(apiName, endpointName, body, urlOptions) {
+        return this.useFetch(apiName, endpointName, {
+            method: "POST",
+            ...serializeBody(body),
+            ...pickUrl(urlOptions),
+        });
+    }
+    /**
+     * PUT helper over a registered API endpoint.
+     *
+     * @param apiName - The registered API key.
+     * @param endpointName - The endpoint key within the API.
+     * @param body - Optional request body (auto-serialized to JSON unless raw).
+     * @param urlOptions - Optional URL building options.
+     * @returns A `FetchResult` with data or error.
+     */
+    async usePut(apiName, endpointName, body, urlOptions) {
+        return this.useFetch(apiName, endpointName, {
+            method: "PUT",
+            ...serializeBody(body),
+            ...pickUrl(urlOptions),
+        });
+    }
+    /**
+     * PATCH helper over a registered API endpoint.
+     *
+     * @param apiName - The registered API key.
+     * @param endpointName - The endpoint key within the API.
+     * @param body - Optional request body (auto-serialized to JSON unless raw).
+     * @param urlOptions - Optional URL building options.
+     * @returns A `FetchResult` with data or error.
+     */
+    async usePatch(apiName, endpointName, body, urlOptions) {
+        return this.useFetch(apiName, endpointName, {
+            method: "PATCH",
+            ...serializeBody(body),
+            ...pickUrl(urlOptions),
+        });
+    }
+    /**
+     * DELETE helper over a registered API endpoint.
+     *
+     * @param apiName - The registered API key.
+     * @param endpointName - The endpoint key within the API.
+     * @param urlOptions - Optional URL building options.
+     * @returns A `FetchResult` with data or error.
+     */
+    async useDelete(apiName, endpointName, urlOptions) {
+        return this.useFetch(apiName, endpointName, {
+            method: "DELETE",
+            ...pickUrl(urlOptions),
+        });
+    }
+}
+/* -------------------------------------------------------------------------- */
+/* define*Config                                                              */
+/* -------------------------------------------------------------------------- */
+/**
+ * Declares the API registry in a single call - the config-file entry point.
  *
  * Registers every {@link ApiEntry} you list and returns them alongside the
  * props, flags and methods declared on the same literal, so one `export default`
@@ -83,7 +398,7 @@ function serializeBody(body) {
  *
  * @typeParam T - The literal passed in.
  * @param input - API entries, flags and methods in one object literal.
- * @returns The registered config plus the declared methods (see {@link ConfigFacade}).
+ * @returns The registered config plus the declared methods (see `ConfigFacade`).
  * @throws {Error} If a non-method value is an object that is not an API entry.
  *
  * @example
@@ -99,7 +414,7 @@ function serializeBody(body) {
  * });
  * ```
  *
- * @remarks Methods must be written with `function`, not as arrows — `this.config`
+ * @remarks Methods must be written with `function`, not as arrows - `this.config`
  * is undefined inside an arrow function.
  */
 export function defineApiConfig(input) {
@@ -119,6 +434,9 @@ export function defineApiConfig(input) {
     // `methods` is a generic spread, so TS cannot prove the exact facade shape.
     return { config, ...methods };
 }
+/* -------------------------------------------------------------------------- */
+/* Wrappers (backward compatibility)                                          */
+/* -------------------------------------------------------------------------- */
 /**
  * Registers (merges) API definitions into the client registry.
  *
@@ -131,36 +449,18 @@ export function defineApiConfig(input) {
  * ```ts
  * import { useInit } from "katanakit-js";
  *
- * useInit({
- *   pokeapi: {
- *     baseUri: "https://pokeapi.co/api/v2",
- *     endpoints: { pokemonById: "/pokemon/:id/" },
- *   },
- * });
+ * useInit({ pokeapi: { baseUri: "https://pokeapi.co/api/v2", endpoints: { pokemonById: "/pokemon/:id/" } } });
  * ```
  */
 export function useInit(apisConfig) {
-    apis = { ...apis, ...apisConfig };
+    FetchApiManager.getInstance().useInit(apisConfig);
 }
 /**
  * Registers (merges) API definitions into the client registry.
  *
- * @deprecated Use {@link defineApiConfig}, which registers the config and
- * returns it with any methods declared on the same literal.
+ * @deprecated Use {@link defineApiConfig}.
  *
  * @param apisConfig - The API definitions to merge into the registry.
- *
- * @example
- * ```ts
- * import { useInitApis } from "katanakit-js";
- *
- * useInitApis({
- *   pokeapi: {
- *     baseUri: "https://pokeapi.co/api/v2",
- *     endpoints: { pokemonById: "/pokemon/:id/" },
- *   },
- * });
- * ```
  */
 export function useInitApis(apisConfig) {
     useInit(apisConfig);
@@ -178,20 +478,12 @@ export function useInitApis(apisConfig) {
  * ```
  */
 export function useGetApis() {
-    return { ...apis };
+    return FetchApiManager.getInstance().useGetApis();
 }
 /**
- * Returns a shallow copy of the registered APIs.
- * Alias for {@link useGetApis}.
+ * Returns a shallow copy of the registered APIs. Alias for {@link useGetApis}.
  *
  * @returns A shallow copy of the current API registry.
- *
- * @example
- * ```ts
- * import { useGetApisConfig } from "katanakit-js";
- *
- * const apis = useGetApisConfig();
- * ```
  */
 export function useGetApisConfig() {
     return useGetApis();
@@ -199,18 +491,7 @@ export function useGetApisConfig() {
 /**
  * Returns the URL of a registered endpoint **without calling `fetch`**.
  *
- * It builds the same URL {@link useFetch} would request — same registry, same
- * `:param` substitution, same `query` merge with `defaultQueryParams`, same
- * http(s) guard — then stops and hands you the string.
- *
- * Use it when you need the **address**, not the response:
- *
- * - `<a href>` / `<img src>` — links and media built from an endpoint name
- * - libraries that fetch on their own (charts, maps, analytics)
- * - logging the exact URL you are about to request
- * - SSR / prerender, where nothing should be requested
- *
- * @param apiName - Registered API key (from {@link defineApiConfig}).
+ * @param apiName - Registered API key (from `defineApiConfig`).
  * @param endpointName - Endpoint key inside that API.
  * @param options - `params` fills `:placeholders`, `query` becomes the search string.
  * @returns The fully built URL.
@@ -222,208 +503,43 @@ export function useGetApisConfig() {
  *
  * useBuildUrl("pokeapi", "pokemonById", { params: { id: 25 } });
  * // → "https://pokeapi.co/api/v2/pokemon/25"
- *
- * useBuildUrl("myApi", "export", { query: { format: "pdf" } });
- * // → "https://api.myapp.com/v1/export?format=pdf"
- *
- * <a href={useBuildUrl("myApi", "download", { params: { id: 42 } })}>Download</a>
  * ```
- *
- * @remarks Synchronous, so it **throws** instead of returning a Safe Result —
- * Safe Result covers fallible async work, and this never leaves the process.
- * To see the URL a request actually used, read `result.url` off a `useFetch`
- * result instead.
  */
 export function useBuildUrl(apiName, endpointName, options = {}) {
-    const { params, query, ignoreDefaultQuery = false } = options;
-    const api = getApiEntry(apiName);
-    let path = api.endpoints?.[endpointName] ?? "";
-    if (!path) {
-        throw new Error(`[FetchApiManager] Endpoint "${endpointName}" not found in API "${apiName}".`);
-    }
-    if (params) {
-        const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        path = Object.entries(params).reduce((acc, [key, value]) => acc.replace(new RegExp(`:${escapeRegex(key)}\\b`, "g"), encodeURIComponent(String(value))), path);
-    }
-    const baseStr = api.baseUri instanceof URL ? api.baseUri.toString() : api.baseUri;
-    const baseClean = baseStr.endsWith("/") ? baseStr.slice(0, -1) : baseStr;
-    const pathClean = path.startsWith("/") ? path : `/${path}`;
-    const url = new URL(`${baseClean}${pathClean}`);
-    // Only allow http(s) to prevent SSRF and `javascript:` URLs.
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error(`[FetchApiManager] Scheme "${url.protocol}" is not allowed.`);
-    }
-    const defaultParams = ignoreDefaultQuery ? {} : (api.defaultQueryParams?.[endpointName] ?? {});
-    const mergedQuery = { ...defaultParams, ...query };
-    for (const [key, value] of Object.entries(mergedQuery)) {
-        if (value !== undefined && value !== null) {
-            url.searchParams.set(key, String(value));
-        }
-    }
-    return url.toString();
+    return FetchApiManager.getInstance().useBuildUrl(apiName, endpointName, options);
 }
 /**
  * Builds a safe http(s) URL from a registered API + endpoint.
  *
- * @deprecated Use {@link useBuildUrl}. This is a behaviourally identical wrapper around it and
- * exists only for backwards compatibility — scheduled for removal in the next major.
+ * @deprecated Use {@link useBuildUrl}. Behaviourally identical wrapper kept
+ * for backwards compatibility - scheduled for removal in the next major.
  *
  * @param apiName - The registered API key.
  * @param endpointName - The endpoint key within the API.
  * @param options - Optional URL building options.
  * @returns The fully constructed URL string.
- *
- * @example
- * ```ts
- * import { useBuildApiUrl } from "katanakit-js";
- *
- * const url = useBuildApiUrl("pokeapi", "pokemonById", { params: { id: 25 } });
- * ```
  */
 export function useBuildApiUrl(apiName, endpointName, options = {}) {
     return useBuildUrl(apiName, endpointName, options);
 }
-/**
- * Picks the URL-building keys out of an options bag so nothing else leaks into
- * the `RequestInit` handed to `fetch`.
- *
- * `useGet`/`usePost`/… accept `UrlOptions`, but JS callers can stuff arbitrary
- * keys in there; spreading the whole bag would let a stray `method`, `headers`
- * or `body` silently override what the wrapper already set.
- *
- * @param urlOptions - Legacy URL options, if any.
- * @returns Only `params`, `query` and `ignoreDefaultQuery`, when defined.
- */
-function pickUrl(urlOptions) {
-    if (!urlOptions)
-        return {};
-    const { params, query, ignoreDefaultQuery } = urlOptions;
-    return {
-        ...(params !== undefined && { params }),
-        ...(query !== undefined && { query }),
-        ...(ignoreDefaultQuery !== undefined && { ignoreDefaultQuery }),
-    };
-}
 /**
  * Fetches a registered endpoint and returns a Safe Result.
  *
- * URL options sit at the top level, next to `method`/`headers`/`body` — no
- * nesting, same shape as `useGet` and Nuxt's `useFetch`.
- *
  * @param apiName - The registered API key.
  * @param endpointName - The endpoint key within the API.
  * @param options - Fetch options: `params`, `query`, `transform` and any `RequestInit` field.
- * @returns A {@link FetchResult} with data or error. Never throws — a failing
- *   `transform` comes back as an error result too.
+ * @returns A `FetchResult` with data or error. Never throws.
  *
  * @example
  * ```ts
  * import { useFetch } from "katanakit-js";
  *
- * const result = await useFetch<{ results: unknown[] }>("pokeapi", "pokemons", {
- *   method: "GET",
- *   query: { limit: 2 },
- *   transform: (body) => ({ results: (body as { results: unknown[] }).results }),
- * });
- * if (result.ok) console.log(result.data.results);
- * ```
- *
- * @example Legacy nested form (deprecated)
- * ```ts
- * useFetch("pokeapi", "pokemonById", { urlOptions: { params: { id: 25 } } });
+ * const result = await useFetch("pokeapi", "pokemonById", { params: { id: 25 } });
+ * if (result.ok) console.log(result.data);
  * ```
  */
-export async function useFetch(apiName, endpointName, { params, query, ignoreDefaultQuery, urlOptions, transform, ...init } = {}) {
-    let url = "";
-    // The flat keys and the deprecated `urlOptions` nest describe the same
-    // thing; the flat form wins. `undefined` means "not given", so it must not
-    // overwrite a value coming from the legacy nest.
-    const buildOptions = { ...urlOptions };
-    if (params !== undefined)
-        buildOptions.params = params;
-    if (query !== undefined)
-        buildOptions.query = query;
-    if (ignoreDefaultQuery !== undefined)
-        buildOptions.ignoreDefaultQuery = ignoreDefaultQuery;
-    try {
-        url = useBuildUrl(apiName, endpointName, buildOptions);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            data: null,
-            error: {
-                message: `Config Error: ${message}`,
-                status: 0,
-            },
-            url,
-            status: 0,
-            ok: false,
-        };
-    }
-    try {
-        // Fail closed on redirects: the scheme allow-list only validates the
-        // initial URL, so following a 3xx could steer the request to a private
-        // host (SSRF). Callers that need redirects can pass `redirect: "follow"`.
-        const response = await fetch(url, { redirect: "error", ...init });
-        if (!response.ok) {
-            const errorDetails = await readBody(response, MAX_ERROR_BODY_CHARS);
-            return {
-                data: null,
-                error: {
-                    message: `HTTP Error: ${response.statusText || "Unsuccessful response"}`,
-                    status: response.status,
-                    details: errorDetails,
-                },
-                url: response.url || url,
-                status: response.status,
-                ok: false,
-            };
-        }
-        // 204 No Content and empty bodies are valid success responses.
-        const body = response.status === 204 ? null : await readBody(response);
-        let data = body;
-        if (transform) {
-            try {
-                data = await transform(body);
-            }
-            catch (err) {
-                // A failing transform is still a failed request — return it as a
-                // Safe Result instead of letting it escape `useFetch`.
-                const message = err instanceof Error ? err.message : String(err);
-                return {
-                    data: null,
-                    error: {
-                        message: `Transform Error: ${message}`,
-                        status: response.status,
-                    },
-                    url: response.url || url,
-                    status: response.status,
-                    ok: false,
-                };
-            }
-        }
-        return {
-            data: data,
-            error: null,
-            url: response.url || url,
-            status: response.status,
-            ok: true,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            data: null,
-            error: {
-                message: `Network/Client Error: ${message}`,
-                status: 0,
-            },
-            url,
-            status: 0,
-            ok: false,
-        };
-    }
+export async function useFetch(apiName, endpointName, options = {}) {
+    return FetchApiManager.getInstance().useFetch(apiName, endpointName, options);
 }
 /**
  * Fetches a registered endpoint and returns a Safe Result.
@@ -432,18 +548,7 @@ export async function useFetch(apiName, endpointName, { params, query, ignoreDef
  * @param apiName - The registered API key.
  * @param endpointName - The endpoint key within the API.
  * @param options - Optional fetch options.
- * @returns A {@link FetchResult} with data or error.
- *
- * @example
- * ```ts
- * import { useFetchApi } from "katanakit-js";
- *
- * const result = await useFetchApi("pokeapi", "pokemonById", {
- *   method: "GET",
- *   params: { id: 25 },
- * });
- * if (result.ok) console.log(result.data);
- * ```
+ * @returns A `FetchResult` with data or error.
  */
 export async function useFetchApi(apiName, endpointName, options) {
     return useFetch(apiName, endpointName, options);
@@ -454,37 +559,25 @@ export async function useFetchApi(apiName, endpointName, options) {
  * @param apiName - The registered API key.
  * @param endpointName - The endpoint key within the API.
  * @param urlOptions - Optional URL building options.
- * @returns A {@link FetchResult} with data or error.
+ * @returns A `FetchResult` with data or error.
  *
  * @example
  * ```ts
  * import { useGet } from "katanakit-js";
  *
- * const result = await useGet<{ name: string }>("pokeapi", "pokemonById", {
- *   params: { id: 25 },
- * });
+ * const result = await useGet("pokeapi", "pokemonById", { params: { id: 25 } });
  * ```
  */
 export async function useGet(apiName, endpointName, urlOptions) {
-    return useFetch(apiName, endpointName, { method: "GET", ...pickUrl(urlOptions) });
+    return FetchApiManager.getInstance().useGet(apiName, endpointName, urlOptions);
 }
 /**
- * GET helper over a registered API endpoint.
- * Alias for {@link useGet}.
+ * GET helper over a registered API endpoint. Alias for {@link useGet}.
  *
  * @param apiName - The registered API key.
  * @param endpointName - The endpoint key within the API.
  * @param urlOptions - Optional URL building options.
- * @returns A {@link FetchResult} with data or error.
- *
- * @example
- * ```ts
- * import { useGetApi } from "katanakit-js";
- *
- * const result = await useGetApi<{ name: string }>("pokeapi", "pokemonById", {
- *   params: { id: 25 },
- * });
- * ```
+ * @returns A `FetchResult` with data or error.
  */
 export async function useGetApi(apiName, endpointName, urlOptions) {
     return useGet(apiName, endpointName, urlOptions);
@@ -496,7 +589,7 @@ export async function useGetApi(apiName, endpointName, urlOptions) {
  * @param endpointName - The endpoint key within the API.
  * @param body - Optional request body (auto-serialized to JSON unless raw).
  * @param urlOptions - Optional URL building options.
- * @returns A {@link FetchResult} with data or error.
+ * @returns A `FetchResult` with data or error.
  *
  * @example
  * ```ts
@@ -506,11 +599,7 @@ export async function useGetApi(apiName, endpointName, urlOptions) {
  * ```
  */
 export async function usePost(apiName, endpointName, body, urlOptions) {
-    return useFetch(apiName, endpointName, {
-        method: "POST",
-        ...serializeBody(body),
-        ...pickUrl(urlOptions),
-    });
+    return FetchApiManager.getInstance().usePost(apiName, endpointName, body, urlOptions);
 }
 /**
  * PUT helper over a registered API endpoint.
@@ -519,21 +608,10 @@ export async function usePost(apiName, endpointName, body, urlOptions) {
  * @param endpointName - The endpoint key within the API.
  * @param body - Optional request body (auto-serialized to JSON unless raw).
  * @param urlOptions - Optional URL building options.
- * @returns A {@link FetchResult} with data or error.
- *
- * @example
- * ```ts
- * import { usePut } from "katanakit-js";
- *
- * const result = await usePut("pokeapi", "updatePokemon", { name: "Raichu" }, { params: { id: 25 } });
- * ```
+ * @returns A `FetchResult` with data or error.
  */
 export async function usePut(apiName, endpointName, body, urlOptions) {
-    return useFetch(apiName, endpointName, {
-        method: "PUT",
-        ...serializeBody(body),
-        ...pickUrl(urlOptions),
-    });
+    return FetchApiManager.getInstance().usePut(apiName, endpointName, body, urlOptions);
 }
 /**
  * PATCH helper over a registered API endpoint.
@@ -542,21 +620,10 @@ export async function usePut(apiName, endpointName, body, urlOptions) {
  * @param endpointName - The endpoint key within the API.
  * @param body - Optional request body (auto-serialized to JSON unless raw).
  * @param urlOptions - Optional URL building options.
- * @returns A {@link FetchResult} with data or error.
- *
- * @example
- * ```ts
- * import { usePatch } from "katanakit-js";
- *
- * const result = await usePatch("pokeapi", "updatePokemon", { name: "Raichu" }, { params: { id: 25 } });
- * ```
+ * @returns A `FetchResult` with data or error.
  */
 export async function usePatch(apiName, endpointName, body, urlOptions) {
-    return useFetch(apiName, endpointName, {
-        method: "PATCH",
-        ...serializeBody(body),
-        ...pickUrl(urlOptions),
-    });
+    return FetchApiManager.getInstance().usePatch(apiName, endpointName, body, urlOptions);
 }
 /**
  * DELETE helper over a registered API endpoint.
@@ -564,19 +631,9 @@ export async function usePatch(apiName, endpointName, body, urlOptions) {
  * @param apiName - The registered API key.
  * @param endpointName - The endpoint key within the API.
  * @param urlOptions - Optional URL building options.
- * @returns A {@link FetchResult} with data or error.
- *
- * @example
- * ```ts
- * import { useDelete } from "katanakit-js";
- *
- * const result = await useDelete("pokeapi", "deletePokemon", { params: { id: 25 } });
- * ```
+ * @returns A `FetchResult` with data or error.
  */
 export async function useDelete(apiName, endpointName, urlOptions) {
-    return useFetch(apiName, endpointName, {
-        method: "DELETE",
-        ...pickUrl(urlOptions),
-    });
+    return FetchApiManager.getInstance().useDelete(apiName, endpointName, urlOptions);
 }
 //# sourceMappingURL=http.service.js.map