@messaia/cdk 18.1.0 → 18.1.1

package/fesm2022/messaia-cdk.mjs

@@ -52,7 +52,7 @@ import * as i1$1 from '@angular/platform-browser';
 import { Title } from '@angular/platform-browser';
 import { __decorate, __metadata } from 'tslib';
 import 'reflect-metadata';
-import { Subject, filter, BehaviorSubject, of, map as map$1, fromEvent, distinctUntilChanged, debounceTime, merge as merge$1, tap, Observable, takeUntil as takeUntil$1 } from 'rxjs';
+import { Subject, filter, BehaviorSubject, throwError, of, map as map$1, fromEvent, distinctUntilChanged, debounceTime, merge as merge$1, tap, Observable, takeUntil as takeUntil$1 } from 'rxjs';
 import { catchError, map, debounceTime as debounceTime$1, distinctUntilChanged as distinctUntilChanged$1, skip, switchMap, takeUntil, tap as tap$1, finalize } from 'rxjs/operators';
 import * as i3$1 from '@angular/cdk/scrolling';
 import { ScrollingModule } from '@angular/cdk/scrolling';
@@ -4203,16 +4203,22 @@ class GenericService {
         return "";
     }
     /**
-     * Returns a function that handles Http operation failures.
-     * This error handler lets the app continue to run as if no error occurred.
-     * @param operation - name of the operation that failed
+     * Handles an HTTP operation that failed.
+     * Allows the application to continue by throwing a parsed error.
+     *
+     * @template T The type of the observable result.
+     * @param operation The name of the operation that failed. Defaults to 'operation'.
+     * @param result An optional value to return as the observable result.
+     * @returns A function that processes the error and returns an observable.
      */
-    handleError(operation = 'operation') {
-        return (error) => {
-            console.log(error);
+    handleError(operation = 'operation', result) {
+        return (error) => throwError(() => {
+            if (error.error instanceof ArrayBuffer) {
+                return JSON.parse(new TextDecoder().decode(new Uint8Array(error.error)));
+            }
             const message = (error.error instanceof ErrorEvent) ? error.error.message : `server returned code ${error.status} with body "${error.error}"`;
-            throw new Error(`${operation} failed: ${message}`);
-        };
+            return `${operation} failed: ${message}`;
+        });
     }
     /**
      * Return distinct message for sent, upload progress, & response events
@@ -23330,55 +23336,56 @@ class BaseInterceptor {
         this.snackBar = snackBar;
     }
     /**
-     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * Intercepts an outgoing `HttpRequest` and optionally transforms it or the
      * response.
      *
      * Typically an interceptor will transform the outgoing request before returning
-     * `next.handle(transformedReq)`. An interceptor may choose to transform the
-     * response event stream as well, by applying additional Rx operators on the stream
-     * returned by `next.handle()`.
+     * `next.handle(transformedReq)`. An interceptor may also choose to transform the
+     * response event stream by applying additional Rx operators.
      *
-     * More rarely, an interceptor may choose to completely handle the request itself,
-     * and compose a new event stream instead of invoking `next.handle()`. This is
-     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     * In rare cases, an interceptor may completely handle the request itself,
+     * creating a new event stream and bypassing `next.handle()`. This is allowed,
+     * but it means that other interceptors will not be triggered.
      *
-     * It is also rare but valid for an interceptor to return multiple responses on the
-     * event stream for a single request.
+     * It's also possible, though rare, for an interceptor to return multiple responses
+     * on the event stream for a single request.
      */
     intercept(req, next) {
-        /* Clone the request and set the base url */
+        /* Clone the request and set the base URL if it's not already an absolute URL */
         const authReq = req.clone({
-            url: req.url.startsWith('http') || req.url.startsWith('./assets') ? req.url : `${this.appSetting.apiUrl}${req.url}`,
+            /* Check if the URL is already absolute or starts with './assets' */
+            url: req.url.startsWith('http') || req.url.startsWith('./assets')
+                ? req.url : `${this.appSetting.apiUrl}${req.url}`,
+            /* Add a custom header for GET requests */
             headers: req.method == 'GET' ? req.headers.set('CheckIn', 'Yes') : req.headers
         });
-        /* Send cloned request with header to the next handler */
+        /* Send the cloned request with added headers to the next handler in the chain */
         return next.handle(authReq).pipe(tap$1(
-        /* Succeeds when there is a response; ignore other events */
+        /* Handle the response */
         event => {
             if (event instanceof HttpResponse) {
+                /* Check for specific headers in the response */
                 if (req.headers.get('Show-Message')) {
-                    /* Show a success message for POST requests */
+                    /* Show success messages for different types of requests */
                     if (req.method == 'POST') {
                         this.snackBar.open($localize `:@@snackbar.send.success:Data sent successfully.`, undefined, {
                             duration: 3000,
                             panelClass: ['primary']
                         });
                     }
-                    /* Show a success message for PUT or PATCH requests */
                     if (['PUT', 'PATCH'].indexOf(req.method) >= 0) {
                         this.snackBar.open($localize `:@@snackbar.update.success:Changes saved successfully.`, undefined, {
                             duration: 3000,
                             panelClass: ['primary']
                         });
                     }
-                    /* Show a success message for PUT or PATCH requests */
                     if (['DELETE'].indexOf(req.method) >= 0) {
                         this.snackBar.open($localize `:@@snackbar.delete.success:Record(s) deleted successfully.`, undefined, {
                             duration: 3000,
                             panelClass: ['primary']
                         });
                     }
-                    /* Show warnings from headers, if any */
+                    /* Show warnings from response headers if available */
                     var warning = event.headers.get("Warning");
                     if (warning) {
                         this.snackBar.open(warning, "OK", { duration: 6000, panelClass: ['warn'] });
@@ -23386,58 +23393,85 @@ class BaseInterceptor {
                 }
             }
         }, 
-        /* Operation failed; error is an HttpErrorResponse */
+        /* Handle errors */
         error => {
-            /* Status: 400 - Bad Request (i.e. validation errors) */
+            /* Handle validation errors for status code 400 (Bad Request) */
             if (error.status == 400) {
                 let message = this.parseErrors(error.error);
                 if (message) {
                     this.snackBar.open(message, "OK", { duration: 8000, panelClass: ['error'] });
                 }
             }
-            /* Status: 403 -  Not permitted */
+            /* Handle permission errors for status code 403 (Forbidden) */
             if (error.status == 403) {
                 this.snackBar.open($localize `:@@snackbar.error.not-allowed:You are not allowed to perform this request.`, undefined, {
                     duration: 6000,
                     panelClass: ['error']
                 });
             }
-            /* Status: 404 -  Bad request, show some error messages */
+            /* Handle not found errors for status code 404 (Not Found) */
             if (error.status == 404) {
                 this.snackBar.open($localize `:@@snackbar.error.not-found:The resource could not be found.`, undefined, {
                     duration: 6000,
                     panelClass: ['error']
                 });
             }
-            /* Custom error message */
+            /* Handle custom error message for status code 452 */
             if (error.status == 452) {
                 this.snackBar.open(error.text(), undefined, { duration: 6000, panelClass: ['error'] });
             }
-            /* Internal server error */
+            /* Handle internal server errors for status code 500 */
             if (error.status == 500) {
                 this.snackBar.open(error.text(), undefined, { duration: 6000, panelClass: ['error'] });
             }
         }));
     }
     /**
-     * Parses http response errors
-     * @param error
+     * Parses HTTP response errors and extracts the error messages.
+     * Handles both ArrayBuffer and structured error objects.
+     *
+     * @param error The error object to parse, which could be an ArrayBuffer or a structured error object.
+     * @returns A string containing all error messages, joined by new lines.
      */
     parseErrors(error) {
         let errors = [];
+        /* Check if error exists before processing */
         if (error) {
-            Object.keys(error).forEach(el => {
-                let err = error[el];
-                if (Array.isArray(err)) {
-                    err.forEach(err => {
-                        errors.push(err);
-                    });
+            /* If the error is an ArrayBuffer, attempt to decode and parse it */
+            if (error instanceof ArrayBuffer) {
+                try {
+                    /* Decode the ArrayBuffer to a string and then parse the JSON */
+                    error = JSON.parse(new TextDecoder().decode(new Uint8Array(error)));
                 }
-                else if (typeof err === "string") {
-                    errors.push(err);
+                catch (err) {
+                    /* Log the error if JSON parsing fails */
+                    console.error("Error parsing ArrayBuffer:", err);
+                    /* Return a generic message if parsing fails */
+                    return "Failed to parse error details.";
                 }
-            });
+            }
+            /* Ensure the error is an object (for structured error responses) */
+            if (typeof error === 'object') {
+                /* Iterate over the keys of the error object */
+                Object.keys(error).forEach(el => {
+                    let err = error[el];
+                    /* If the value is an array, iterate over each element */
+                    if (Array.isArray(err)) {
+                        err.forEach(e => {
+                            /* Ensure each element is a string before adding to errors */
+                            if (typeof e === 'string') {
+                                errors.push(e);
+                            }
+                        });
+                    }
+                    else if (typeof err === 'string') {
+                        /* If the value is a string, add it directly to the errors list */
+                        errors.push(err);
+                    }
+                });
+            }
         }
+        /* Join the error messages with newlines and return the result */
         return errors.join('\n');
     }
     /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: BaseInterceptor, deps: [{ token: AppSetting }, { token: i2$4.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });