@hashrytech/quick-components-kit 0.19.10 → 0.19.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @hashrytech/quick-components-kit
 
+## 0.19.12
+
+### Patch Changes
+
+- fix: Adjusting 2 error handlers so that 1 returns problem details and the other returns the default error
+
+## 0.19.11
+
+### Patch Changes
+
+- fix: Fixing event handlers for fetch
+
 ## 0.19.10
 
 ### Patch Changes

package/dist/modules/fetch-client.d.ts

@@ -63,9 +63,9 @@ export declare class FetchError extends Error {
     constructor(message: string, status: number, json?: object);
 }
 export interface FetchClientEvents {
-    onRequest?: (request: Request) => void;
-    onResponse?: (response: Response) => void;
-    onError?: (error: Error) => void;
+    onRequest?: (request: Request) => Promise<void> | void;
+    onResponse?: (response: Response) => Promise<void> | void;
+    onError?: (error: ProblemDetail) => Promise<void> | void;
 }
 /**
  * A generic REST API client.
@@ -126,6 +126,23 @@ export declare class FetchClient {
      */
     addErrorHandler(handler: ErrorHandler): void;
     setEventHooks(events: Partial<FetchClientEvents>): void;
+    /**
+     * Emits a typed event to a single-argument handler (if registered).
+     *
+     * Why `Parameters<...>[0]`?
+     * - `FetchClientEvents[K]` is a function type (or undefined). `NonNullable<>` removes `undefined`.
+     * - `Parameters<F>[0]` extracts the first parameter type of that function.
+     * - This keeps the arg type in sync with your `FetchClientEvents` definition.
+     *
+     * Notes:
+     * - This variant assumes each event handler accepts exactly one argument.
+     * - Handlers may be sync or async; both are awaited via `Promise.resolve(...)`.
+     * - Errors thrown by a handler are caught and logged so they don't break the request flow.
+     *
+     * If you later need multiple args per event, prefer a tuple map approach
+     * (e.g. `type EventArgsMap = { onRequest: [Request]; ... }`) to keep spreads type-safe.
+    */
+    private emit;
     /**
      * Processes the request, applying default headers, auth token, and request interceptors.
      * @param endpoint - The API endpoint (e.g., '/products', '/users/123').

package/dist/modules/fetch-client.js

@@ -49,6 +49,7 @@ export class FetchClient {
         this.defaultHeaders = config.defaultHeaders || { 'Content-Type': 'application/json' };
         this.autoRedirects = config.autoRedirects || [];
         this.debug = config.debug || false;
+        this.events = config.events ?? {};
     }
     /**
      * Sets the Bearer token for client-side requests.
@@ -90,6 +91,34 @@ export class FetchClient {
     setEventHooks(events) {
         Object.assign(this.events, events);
     }
+    /**
+     * Emits a typed event to a single-argument handler (if registered).
+     *
+     * Why `Parameters<...>[0]`?
+     * - `FetchClientEvents[K]` is a function type (or undefined). `NonNullable<>` removes `undefined`.
+     * - `Parameters<F>[0]` extracts the first parameter type of that function.
+     * - This keeps the arg type in sync with your `FetchClientEvents` definition.
+     *
+     * Notes:
+     * - This variant assumes each event handler accepts exactly one argument.
+     * - Handlers may be sync or async; both are awaited via `Promise.resolve(...)`.
+     * - Errors thrown by a handler are caught and logged so they don't break the request flow.
+     *
+     * If you later need multiple args per event, prefer a tuple map approach
+     * (e.g. `type EventArgsMap = { onRequest: [Request]; ... }`) to keep spreads type-safe.
+    */
+    async emit(name, arg) {
+        const handler = this.events[name];
+        if (!handler)
+            return;
+        try {
+            await Promise.resolve(handler(arg));
+        }
+        catch (e) {
+            if (this.debug)
+                console.warn(`FetchClient ${String(name)} handler threw`, e);
+        }
+    }
     /**
      * Processes the request, applying default headers, auth token, and request interceptors.
      * @param endpoint - The API endpoint (e.g., '/products', '/users/123').
@@ -149,6 +178,8 @@ export class FetchClient {
         for (const interceptor of this.requestInterceptors) {
             request = await Promise.resolve(interceptor(request));
         }
+        //this.events.onRequest?.(request);
+        await this.emit('onRequest', request.clone());
         return request;
     }
     /**
@@ -236,6 +267,8 @@ export class FetchClient {
         try {
             const request = await this.processRequest(endpoint, method, body, options);
             const response = await currentFetch(request);
+            //this.events.onResponse?.(response.clone());
+            await this.emit('onResponse', response.clone());
             const parsed = await this.processResponse(response, options);
             return {
                 ok: true,
@@ -251,6 +284,7 @@ export class FetchClient {
             const status = isApiError ? error.status : 503; // Service Unavailable fallback
             const message = error instanceof Error ? error.message : 'Unexpected error occurred';
             const errorObj = isApiError && error.json ? error.json : getProblemDetail({ status, title: "Server fetch error", type: "/exceptions/fetch-error/", detail: message });
+            await this.emit('onError', errorObj);
             //const errorObj = status != 503 ? message : getProblemDetail({status, title: "Server fetch error", type: "/exceptions/fetch-error/", detail: "Error fetching data from API", server: message });
             this.evaluateRedirect(errorObj, status);
             return {

package/package.json

@@ -5,7 +5,7 @@
     "type": "git",
     "url": "git+https://github.com/hashrytech/quick-components-kit.git"
   },
-  "version": "0.19.10",
+  "version": "0.19.12",
   "license": "MIT",
   "author": "Hashry Tech",
   "files": [