coer-elements 0.0.20 → 0.0.21

package/components/lib/coer-button/coer-button.component.d.ts

@@ -8,7 +8,7 @@ export declare class CoerButton implements OnInit, OnDestroy {
     id: string;
     color: import("@angular/core").InputSignal<"warning" | "danger" | "success" | "default" | "primary" | "secondary" | "navigation">;
     type: import("@angular/core").InputSignal<"icon" | "filled" | "outline" | "icon-outline" | "icon-no-border">;
-    icon: import("@angular/core").InputSignal<"" | "cancel" | "menu" | "delete" | "new" | "save" | "import" | "excel" | "edit" | "go" | "back">;
+    icon: import("@angular/core").InputSignal<"" | "delete" | "new" | "save" | "cancel" | "import" | "excel" | "menu" | "edit" | "go" | "back">;
     iconPosition: import("@angular/core").InputSignal<"left" | "right">;
     animation: import("@angular/core").InputSignal<boolean>;
     isLoading: import("@angular/core").InputSignal<boolean>;
@@ -23,7 +23,7 @@ export declare class CoerButton implements OnInit, OnDestroy {
     marginBottom: import("@angular/core").InputSignal<string>;
     marginLeft: import("@angular/core").InputSignal<string>;
     path: import("@angular/core").InputSignal<string | (string | number)[]>;
-    tooltipPosition: import("@angular/core").InputSignal<"top" | "bottom" | "left" | "right">;
+    tooltipPosition: import("@angular/core").InputSignal<"left" | "right" | "top" | "bottom">;
     set tooltip(value: string);
     onClick: EventEmitter<MouseEvent>;
     protected _isEnable: import("@angular/core").Signal<boolean>;

package/components/lib/coer-numberbox/coer-numberbox.component.d.ts

@@ -31,7 +31,7 @@ export declare class CoerNumberBox extends ControlValue implements OnInit {
     isReadonly: import("@angular/core").InputSignal<boolean>;
     isLoading: import("@angular/core").InputSignal<boolean>;
     selectOnFocus: import("@angular/core").InputSignal<boolean>;
-    textPosition: import("@angular/core").InputSignal<"center" | "left" | "right">;
+    textPosition: import("@angular/core").InputSignal<"left" | "right" | "center">;
     onKeyupEnter: import("@angular/core").OutputEmitterRef<string | number>;
     onInput: import("@angular/core").OutputEmitterRef<string | number>;
     ngOnInit(): void;

package/components/lib/coer-switch/coer-switch.component.d.ts

@@ -15,7 +15,7 @@ export declare class CoerSwitch extends ControlValue implements OnInit, OnDestro
     isDisabled: import("@angular/core").InputSignal<boolean>;
     isLoading: import("@angular/core").InputSignal<boolean>;
     isInvisible: import("@angular/core").InputSignal<boolean>;
-    tooltipPosition: import("@angular/core").InputSignal<"top" | "bottom" | "left" | "right">;
+    tooltipPosition: import("@angular/core").InputSignal<"left" | "right" | "top" | "bottom">;
     set tooltip(value: string);
     onChange: import("@angular/core").OutputEmitterRef<boolean>;
     ngOnInit(): void;

package/components/lib/coer-textarea/coer-textarea.component.d.ts

@@ -28,7 +28,7 @@ export declare class CoerTextarea extends ControlValue implements OnInit {
     isLoading: import("@angular/core").InputSignal<boolean>;
     showFooter: import("@angular/core").InputSignal<boolean>;
     resize: import("@angular/core").InputSignal<boolean>;
-    textPosition: import("@angular/core").InputSignal<"center" | "left" | "right">;
+    textPosition: import("@angular/core").InputSignal<"left" | "right" | "center">;
     onInput: import("@angular/core").OutputEmitterRef<string | number>;
     ngOnInit(): void;
     get value(): string | number | null | undefined;

package/components/lib/coer-textbox/coer-textbox.component.d.ts

@@ -29,7 +29,7 @@ export declare class CoerTextBox extends ControlValue implements OnInit {
     isReadonly: import("@angular/core").InputSignal<boolean>;
     isLoading: import("@angular/core").InputSignal<boolean>;
     selectOnFocus: import("@angular/core").InputSignal<boolean>;
-    textPosition: import("@angular/core").InputSignal<"center" | "left" | "right">;
+    textPosition: import("@angular/core").InputSignal<"left" | "right" | "center">;
     onKeyupEnter: import("@angular/core").OutputEmitterRef<string | number>;
     onInput: import("@angular/core").OutputEmitterRef<string | number>;
     onClickClear: import("@angular/core").OutputEmitterRef<void>;

package/esm2022/pipes/lib/no-image.pipe.mjs

@@ -3,7 +3,7 @@ import { Tools } from '../../tools/lib/tools';
 import * as i0 from "@angular/core";
 export class NoImagePipe {
     transform(value) {
-        const NO_IMAGE = '../../images/no-image.png';
+        const NO_IMAGE = '../../../images/no-image.png';
         if (Tools.IsOnlyWhiteSpace(value)) {
             return NO_IMAGE;
         }
@@ -20,4 +20,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             type: Pipe,
             args: [{ name: 'noImage' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8taW1hZ2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvZXItZWxlbWVudHMvc3JjL3BpcGVzL2xpYi9uby1pbWFnZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBQ3BELE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFHOUMsTUFBTSxPQUFPLFdBQVc7SUFFcEIsU0FBUyxDQUFDLEtBQXVDO1FBQzdDLE1BQU0sUUFBUSxHQUFHLDJCQUEyQixDQUFDO1FBRTdDLElBQUcsS0FBSyxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxFQUFHLENBQUM7WUFDaEMsT0FBTyxRQUFRLENBQUM7UUFDcEIsQ0FBQzthQUVJLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDakMsT0FBTyxLQUFLLENBQUM7UUFDakIsQ0FBQztRQUVELHlFQUF5RTtRQUN6RSxPQUFPLFFBQVEsQ0FBQztJQUNwQixDQUFDOytHQWZRLFdBQVc7NkdBQVgsV0FBVzs7NEZBQVgsV0FBVztrQkFEdkIsSUFBSTttQkFBQyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFRvb2xzIH0gZnJvbSAnLi4vLi4vdG9vbHMvbGliL3Rvb2xzJztcclxuXHJcbkBQaXBlKHsgbmFtZTogJ25vSW1hZ2UnIH0pXHJcbmV4cG9ydCBjbGFzcyBOb0ltYWdlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICAgIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nIHwgRmlsZSB8IG51bGwgfCB1bmRlZmluZWQpOiBzdHJpbmcge1xyXG4gICAgICAgIGNvbnN0IE5PX0lNQUdFID0gJy4uLy4uL2ltYWdlcy9uby1pbWFnZS5wbmcnO1xyXG5cclxuICAgICAgICBpZihUb29scy5Jc09ubHlXaGl0ZVNwYWNlKHZhbHVlKSApIHtcclxuICAgICAgICAgICAgcmV0dXJuIE5PX0lNQUdFO1xyXG4gICAgICAgIH1cclxuXHJcbiAgICAgICAgZWxzZSBpZiAodHlwZW9mIHZhbHVlID09PSAnc3RyaW5nJykge1xyXG4gICAgICAgICAgICByZXR1cm4gdmFsdWU7XHJcbiAgICAgICAgfVxyXG5cclxuICAgICAgICAvL0ZpbGVzLkNvbnZlcnRUb0Jhc2U2NCh2YWx1ZSBhcyBGaWxlKS50aGVuKGJhc2U2NCA9PiB7IHJldHVybiBiYXNlNjQgfSk7XHJcbiAgICAgICAgcmV0dXJuIE5PX0lNQUdFO1xyXG4gICAgfVxyXG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8taW1hZ2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvZXItZWxlbWVudHMvc3JjL3BpcGVzL2xpYi9uby1pbWFnZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBQ3BELE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFHOUMsTUFBTSxPQUFPLFdBQVc7SUFFcEIsU0FBUyxDQUFDLEtBQXVDO1FBQzdDLE1BQU0sUUFBUSxHQUFHLDhCQUE4QixDQUFDO1FBRWhELElBQUcsS0FBSyxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxFQUFHLENBQUM7WUFDaEMsT0FBTyxRQUFRLENBQUM7UUFDcEIsQ0FBQzthQUVJLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDakMsT0FBTyxLQUFLLENBQUM7UUFDakIsQ0FBQztRQUVELHlFQUF5RTtRQUN6RSxPQUFPLFFBQVEsQ0FBQztJQUNwQixDQUFDOytHQWZRLFdBQVc7NkdBQVgsV0FBVzs7NEZBQVgsV0FBVztrQkFEdkIsSUFBSTttQkFBQyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFRvb2xzIH0gZnJvbSAnLi4vLi4vdG9vbHMvbGliL3Rvb2xzJztcclxuXHJcbkBQaXBlKHsgbmFtZTogJ25vSW1hZ2UnIH0pXHJcbmV4cG9ydCBjbGFzcyBOb0ltYWdlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICAgIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nIHwgRmlsZSB8IG51bGwgfCB1bmRlZmluZWQpOiBzdHJpbmcge1xyXG4gICAgICAgIGNvbnN0IE5PX0lNQUdFID0gJy4uLy4uLy4uL2ltYWdlcy9uby1pbWFnZS5wbmcnO1xyXG5cclxuICAgICAgICBpZihUb29scy5Jc09ubHlXaGl0ZVNwYWNlKHZhbHVlKSApIHtcclxuICAgICAgICAgICAgcmV0dXJuIE5PX0lNQUdFO1xyXG4gICAgICAgIH1cclxuXHJcbiAgICAgICAgZWxzZSBpZiAodHlwZW9mIHZhbHVlID09PSAnc3RyaW5nJykge1xyXG4gICAgICAgICAgICByZXR1cm4gdmFsdWU7XHJcbiAgICAgICAgfVxyXG5cclxuICAgICAgICAvL0ZpbGVzLkNvbnZlcnRUb0Jhc2U2NCh2YWx1ZSBhcyBGaWxlKS50aGVuKGJhc2U2NCA9PiB7IHJldHVybiBiYXNlNjQgfSk7XHJcbiAgICAgICAgcmV0dXJuIE5PX0lNQUdFO1xyXG4gICAgfVxyXG59Il19

package/esm2022/public_api.mjs

@@ -3,4 +3,4 @@ export * from './directives';
 export * from './pipes';
 export * from './signals';
 export * from './tools';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvZXItZWxlbWVudHMvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMnOyBcclxuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzJztcclxuZXhwb3J0ICogZnJvbSAnLi9waXBlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2lnbmFscyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHMnOyJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvZXItZWxlbWVudHMvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL3BpcGVzJztcclxuZXhwb3J0ICogZnJvbSAnLi9zaWduYWxzJztcclxuZXhwb3J0ICogZnJvbSAnLi90b29scyc7Il19

package/esm2022/tools/index.mjs

@@ -2,9 +2,10 @@ export * from './lib/breadcrumbs.class';
 export * from './lib/control-value.class';
 export * from './lib/date-time.class';
 export * from './lib/files.class';
-export * from './lib/tools';
 export * from './lib/menu.class';
 export * from './lib/page.class';
 export * from './lib/screen.class';
+export * from './lib/service.class';
 export * from './lib/source.class';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb2VyLWVsZW1lbnRzL3NyYy90b29scy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9icmVhZGNydW1icy5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbnRyb2wtdmFsdWUuY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kYXRlLXRpbWUuY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9maWxlcy5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Rvb2xzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BhZ2UuY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zY3JlZW4uY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zb3VyY2UuY2xhc3MnOyJdfQ==
+export * from './lib/tools';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb2VyLWVsZW1lbnRzL3NyYy90b29scy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2JyZWFkY3J1bWJzLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29udHJvbC12YWx1ZS5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RhdGUtdGltZS5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2ZpbGVzLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BhZ2UuY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zY3JlZW4uY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc291cmNlLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvdG9vbHMnOyJdfQ==

package/esm2022/tools/lib/service.class.mjs

@@ -0,0 +1,248 @@
+import { inject } from "@angular/core";
+import { HttpClient, HttpRequest } from "@angular/common/http";
+import { CoerAlert } from "../../components/lib/coer-alert/coer-alert.component";
+import { Tools } from "../../tools/lib/tools";
+export class Service {
+    constructor() {
+        //Injections
+        this.alert = inject(CoerAlert);
+        this.http = inject(HttpClient);
+        this.httpCode = {
+            Ok: 200,
+            Created: 201,
+            NoContent: 204,
+            BadRequest: 400,
+            Unauthorize: 401,
+            NotFound: 404,
+            NotAllowed: 405,
+            NotAcceptable: 406,
+            Conflict: 409,
+            PayloadTooLarge: 413,
+            InnerError: 500
+        };
+    }
+    /** */
+    ReleaseSubscription(subscription) {
+        if (subscription && !subscription.closed)
+            subscription.unsubscribe();
+    }
+    /** HTTP GET */
+    HTTP_GET(request) {
+        return new Promise(Resolve => {
+            this.ReleaseSubscription(this._GET$);
+            this._GET$ = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
+                        Resolve({
+                            body: Tools.BreakReference(response.body),
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(this._GET$);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(this._GET$);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess);
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP POST */
+    HTTP_POST(request) {
+        return new Promise(Resolve => {
+            this.ReleaseSubscription(this._POST$);
+            this._POST$ = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
+                        Resolve({
+                            body: Tools.BreakReference(response.body),
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(this._POST$);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(this._POST$);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess);
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP PUT */
+    HTTP_PUT(request) {
+        return new Promise(Resolve => {
+            this.ReleaseSubscription(this._PUT$);
+            this._PUT$ = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
+                        Resolve({
+                            body: {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(this._PUT$);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(this._PUT$);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP PATCH */
+    HTTP_PATCH(request) {
+        return new Promise(Resolve => {
+            this.ReleaseSubscription(this._PATCH$);
+            this._PATCH$ = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
+                        Resolve({
+                            body: {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(this._PATCH$);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(this._PATCH$);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP DELETE */
+    HTTP_DELETE(request) {
+        return new Promise(Resolve => {
+            this.ReleaseSubscription(this._DELETE$);
+            this._DELETE$ = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
+                        Resolve({
+                            body: {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(this._DELETE$);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(this._DELETE$);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
+                    }
+                }
+            });
+        });
+    }
+    /** */
+    AlertError(httpError, message) {
+        if (httpError.status >= 500) {
+            if (Tools.IsNotOnlyWhiteSpace(message)) {
+                this.alert.Error('', message, 'fa-solid fa-bug', null);
+            }
+        }
+        else if (httpError.status < 500) {
+            switch (httpError.status) {
+                case 400: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Bad Request', 'fa-regular fa-face-grin-beam-sweat fa-lg');
+                    break;
+                }
+                case 401: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Unauthorize', 'fa-regular fa-face-rolling-eyes fa-lg');
+                    break;
+                }
+                case 404: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Found', 'fa-regular fa-face-meh fa-lg');
+                    break;
+                }
+                case 405: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Allowed', 'fa-regular fa-face-grimace fa-lg');
+                    break;
+                }
+                case 406: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Acceptable', 'fa-regular fa-face-frown-open fa-lg');
+                    break;
+                }
+                case 409: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Conflict', 'fa-regular fa-face-dizzy fa-lg');
+                    break;
+                }
+                case 413: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Too Large', 'fa-regular fa-face-flushed fa-lg');
+                    break;
+                }
+                default: {
+                    if (httpError.status <= 0) {
+                        this.alert.Warning('Without Connection', 'WEB API DOWN', 'fa-solid fa-plug-circle-xmark fa-lg', null);
+                    }
+                    else
+                        this.alert.Warning(httpError.error?.message || httpError.error);
+                    break;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.class.js","sourceRoot":"","sources":["../../../../../projects/coer-elements/src/tools/lib/service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from \"@angular/core\";\r\nimport { HttpClient, HttpErrorResponse, HttpEvent, HttpRequest } from \"@angular/common/http\";\r\nimport { CoerAlert } from \"../../components/lib/coer-alert/coer-alert.component\";\r\nimport { IHttpRequest, IHttpResponse } from \"../../interfaces\";\r\nimport { Tools } from \"../../tools/lib/tools\";\r\nimport { Subscription } from \"rxjs\";\r\n\r\nexport class Service {\r\n\r\n    //Injections\r\n    protected readonly alert = inject(CoerAlert);\r\n    protected readonly http = inject(HttpClient);\r\n\r\n    protected httpCode = {\r\n        Ok: 200,\r\n        Created: 201,\r\n        NoContent: 204,\r\n        BadRequest: 400,\r\n        Unauthorize: 401,\r\n        NotFound: 404,\r\n        NotAllowed: 405,\r\n        NotAcceptable: 406,\r\n        Conflict: 409,\r\n        PayloadTooLarge: 413,\r\n        InnerError: 500\r\n    }\r\n\r\n\r\n    //Subscriptions\r\n    private _GET$!: Subscription;\r\n    private _POST$!: Subscription;\r\n    private _PUT$!: Subscription;\r\n    private _PATCH$!: Subscription;\r\n    private _DELETE$!: Subscription;\r\n\r\n\r\n    /** */\r\n    private ReleaseSubscription(subscription: Subscription): void {\r\n        if (subscription && !subscription.closed) subscription.unsubscribe();\r\n    }\r\n\r\n\r\n    /** HTTP GET */\r\n    protected HTTP_GET<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<T>>(Resolve => {\r\n            this.ReleaseSubscription(this._GET$);\r\n\r\n            this._GET$ = this.http.request<T>(new HttpRequest(\"GET\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: Tools.BreakReference<T>(response.body),\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._GET$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._GET$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess);\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP POST */\r\n    protected HTTP_POST<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<T>>(Resolve => {\r\n            this.ReleaseSubscription(this._POST$);\r\n\r\n            this._POST$ = this.http.request<T>(new HttpRequest(\"POST\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: Tools.BreakReference<T>(response.body),\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._POST$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._POST$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess);\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP PUT */\r\n    protected HTTP_PUT<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            this.ReleaseSubscription(this._PUT$);\r\n\r\n            this._PUT$ = this.http.request<T>(new HttpRequest(\"PUT\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._PUT$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._PUT$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP PATCH */\r\n    protected HTTP_PATCH<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            this.ReleaseSubscription(this._PATCH$);\r\n\r\n            this._PATCH$ = this.http.request<T>(new HttpRequest(\"PATCH\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._PATCH$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._PATCH$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP DELETE */\r\n    protected HTTP_DELETE<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            this.ReleaseSubscription(this._DELETE$);\r\n\r\n            this._DELETE$ = this.http.request<T>(new HttpRequest(\"DELETE\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._DELETE$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._DELETE$);\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** */\r\n    private AlertError(httpError: HttpErrorResponse, message?: string): void {\r\n        if (httpError.status >= 500) {\r\n            if (Tools.IsNotOnlyWhiteSpace(message)) {\r\n                this.alert.Error('', message, 'fa-solid fa-bug', null);\r\n            }\r\n        }\r\n\r\n        else if (httpError.status < 500) {\r\n            switch(httpError.status) {\r\n                case 400: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Bad Request', 'fa-regular fa-face-grin-beam-sweat fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 401: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Unauthorize', 'fa-regular fa-face-rolling-eyes fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 404: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Found', 'fa-regular fa-face-meh fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 405: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Allowed', 'fa-regular fa-face-grimace fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 406: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Acceptable', 'fa-regular fa-face-frown-open fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 409: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Conflict', 'fa-regular fa-face-dizzy fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 413: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Too Large', 'fa-regular fa-face-flushed fa-lg');\r\n                    break;\r\n                }\r\n\r\n                default: {\r\n                    if (httpError.status <= 0) {\r\n                        this.alert.Warning('Without Connection', 'WEB API DOWN', 'fa-solid fa-plug-circle-xmark fa-lg', null);\r\n                    }\r\n\r\n                    else this.alert.Warning(httpError.error?.message || httpError.error);\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n}"]}