coer-elements 1.1.9 → 1.1.11

package/fesm2022/coer-elements-services.mjs

@@ -12,13 +12,13 @@ class JWTService {
         return User.Get()?.jwt || '';
     }
     /** */
-    get GetExpirationDate() {
+    get expirationDate() {
         return Tools.IsNotOnlyWhiteSpace(this.jwt) && Tools.IsNotNull(this.jwtService.getTokenExpirationDate(this.jwt))
             ? DateTime.GetFormatDB(this.jwtService.getTokenExpirationDate(this.jwt))
             : null;
     }
     /** */
-    get IsExpired() {
+    get isExpired() {
         return Tools.IsNotOnlyWhiteSpace(this.jwt)
             ? this.jwtService.isTokenExpired(this.jwt)
             : true;

package/fesm2022/coer-elements-services.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"coer-elements-services.mjs","sources":["../../../projects/coer-elements/services/lib/jwt.service.ts","../../../projects/coer-elements/services/lib/services.module.ts","../../../projects/coer-elements/services/coer-elements-services.ts"],"sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { JwtHelperService } from '@auth0/angular-jwt';\r\nimport { DateTime, Tools, User } from 'coer-elements/tools'; \r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class JWTService {\r\n\r\n    private readonly jwtService = inject(JwtHelperService);\r\n    \r\n    \r\n    /** */\r\n    public get jwt(): string {\r\n        return User.Get<any>()?.jwt || '';\r\n    }\r\n\r\n    \r\n    /** */\r\n    public get GetExpirationDate(): string | null { \r\n        return Tools.IsNotOnlyWhiteSpace(this.jwt) && Tools.IsNotNull(this.jwtService.getTokenExpirationDate(this.jwt))\r\n            ? DateTime.GetFormatDB(this.jwtService.getTokenExpirationDate(this.jwt)!)\r\n            : null\r\n    }\r\n\r\n\r\n    /** */\r\n    public get IsExpired(): boolean {  \r\n        return Tools.IsNotOnlyWhiteSpace(this.jwt)\r\n            ? this.jwtService.isTokenExpired(this.jwt)\r\n            : true\r\n    }\r\n}","import { NgModule } from '@angular/core'; \r\n\r\n//Services\r\nimport { JWTService } from './jwt.service';\r\n\r\n@NgModule({    \r\n    providers: [  \r\n        JWTService \r\n    ]\r\n})\r\nexport class ServicesModule { }","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;;;;MAOa,UAAU,CAAA;AAHvB,IAAA,WAAA,GAAA;AAKqB,QAAA,IAAA,CAAA,UAAU,GAAG,MAAM,CAAC,gBAAgB,CAAC;AAuBzD;;AAnBG,IAAA,IAAW,GAAG,GAAA;QACV,OAAO,IAAI,CAAC,GAAG,EAAO,EAAE,GAAG,IAAI,EAAE;;;AAKrC,IAAA,IAAW,iBAAiB,GAAA;QACxB,OAAO,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC;AAC1G,cAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAE;cACtE,IAAI;;;AAKd,IAAA,IAAW,SAAS,GAAA;AAChB,QAAA,OAAO,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG;cACnC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG;cACvC,IAAI;;8GAvBL,UAAU,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,UAAA,EAAA,CAAA,CAAA;AAAV,IAAA,SAAA,IAAA,CAAA,KAAA,GAAA,EAAA,CAAA,qBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,UAAU,cAFP,MAAM,EAAA,CAAA,CAAA;;2FAET,UAAU,EAAA,UAAA,EAAA,CAAA;kBAHtB,UAAU;AAAC,YAAA,IAAA,EAAA,CAAA;AACR,oBAAA,UAAU,EAAE;AACf,iBAAA;;;MCIY,cAAc,CAAA;8GAAd,cAAc,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,QAAA,EAAA,CAAA,CAAA;+GAAd,cAAc,EAAA,CAAA,CAAA;AAAd,IAAA,SAAA,IAAA,CAAA,IAAA,GAAA,EAAA,CAAA,mBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,cAAc,EAJZ,SAAA,EAAA;YACP;AACH,SAAA,EAAA,CAAA,CAAA;;2FAEQ,cAAc,EAAA,UAAA,EAAA,CAAA;kBAL1B,QAAQ;AAAC,YAAA,IAAA,EAAA,CAAA;AACN,oBAAA,SAAS,EAAE;wBACP;AACH;AACJ,iBAAA;;;ACTD;;AAEG;;;;"}
+{"version":3,"file":"coer-elements-services.mjs","sources":["../../../projects/coer-elements/services/lib/jwt.service.ts","../../../projects/coer-elements/services/lib/services.module.ts","../../../projects/coer-elements/services/coer-elements-services.ts"],"sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { JwtHelperService } from '@auth0/angular-jwt';\r\nimport { DateTime, Tools, User } from 'coer-elements/tools';  \r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class JWTService {\r\n\r\n    private readonly jwtService = inject(JwtHelperService);\r\n    \r\n    \r\n    /** */\r\n    public get jwt(): string { \r\n        return User.Get<any>()?.jwt || '';\r\n    }\r\n\r\n    \r\n    /** */\r\n    public get expirationDate(): string | null { \r\n        return Tools.IsNotOnlyWhiteSpace(this.jwt) && Tools.IsNotNull(this.jwtService.getTokenExpirationDate(this.jwt))\r\n            ? DateTime.GetFormatDB(this.jwtService.getTokenExpirationDate(this.jwt)!)\r\n            : null\r\n    }\r\n\r\n\r\n    /** */\r\n    public get isExpired(): boolean {  \r\n        return Tools.IsNotOnlyWhiteSpace(this.jwt)\r\n            ? this.jwtService.isTokenExpired(this.jwt)\r\n            : true\r\n    }\r\n}","import { NgModule } from '@angular/core'; \r\n\r\n//Services\r\nimport { JWTService } from './jwt.service';\r\n\r\n@NgModule({    \r\n    providers: [  \r\n        JWTService \r\n    ]\r\n})\r\nexport class ServicesModule { }","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;;;;MAOa,UAAU,CAAA;AAHvB,IAAA,WAAA,GAAA;AAKqB,QAAA,IAAA,CAAA,UAAU,GAAG,MAAM,CAAC,gBAAgB,CAAC;AAuBzD;;AAnBG,IAAA,IAAW,GAAG,GAAA;QACV,OAAO,IAAI,CAAC,GAAG,EAAO,EAAE,GAAG,IAAI,EAAE;;;AAKrC,IAAA,IAAW,cAAc,GAAA;QACrB,OAAO,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC;AAC1G,cAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAE;cACtE,IAAI;;;AAKd,IAAA,IAAW,SAAS,GAAA;AAChB,QAAA,OAAO,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG;cACnC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG;cACvC,IAAI;;8GAvBL,UAAU,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,UAAA,EAAA,CAAA,CAAA;AAAV,IAAA,SAAA,IAAA,CAAA,KAAA,GAAA,EAAA,CAAA,qBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,UAAU,cAFP,MAAM,EAAA,CAAA,CAAA;;2FAET,UAAU,EAAA,UAAA,EAAA,CAAA;kBAHtB,UAAU;AAAC,YAAA,IAAA,EAAA,CAAA;AACR,oBAAA,UAAU,EAAE;AACf,iBAAA;;;MCIY,cAAc,CAAA;8GAAd,cAAc,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,QAAA,EAAA,CAAA,CAAA;+GAAd,cAAc,EAAA,CAAA,CAAA;AAAd,IAAA,SAAA,IAAA,CAAA,IAAA,GAAA,EAAA,CAAA,mBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,cAAc,EAJZ,SAAA,EAAA;YACP;AACH,SAAA,EAAA,CAAA,CAAA;;2FAEQ,cAAc,EAAA,UAAA,EAAA,CAAA;kBAL1B,QAAQ;AAAC,YAAA,IAAA,EAAA,CAAA;AACN,oBAAA,SAAS,EAAE;wBACP;AACH;AACJ,iBAAA;;;ACTD;;AAEG;;;;"}

package/fesm2022/coer-elements-tools.mjs

@@ -1511,381 +1511,221 @@ class Service {
     /** HTTP GET */
     HTTP_GET(request, cancelPrevious = true) {
         return new Promise(Resolve => {
+            let subscription;
             if (cancelPrevious) {
-                this.ReleaseSubscription(this._GET$);
-                this._GET$ = this.http.request(new HttpRequest("GET", request.url, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: 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);
-                        }
-                    }
-                });
+                let subscription = this._GET$;
+                this.ReleaseSubscription(subscription);
             }
-            else {
-                const subscription = this.http.request(new HttpRequest("GET", request.url, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: response.body,
-                                status: response.status,
-                                message: response.statusText,
-                                ok: true
-                            });
-                        }
-                    },
-                    error: (httpError) => {
-                        this.ReleaseSubscription(subscription);
-                        this.AlertError(httpError, request.alertError);
+            const responseType = request?.responseType || 'json';
+            subscription = this.http.request(new HttpRequest("GET", request.url, {
+                params: request.queryParams,
+                headers: request.headers,
+                responseType: responseType,
+                withCredentials: request.withCredentials
+            })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
                         Resolve({
-                            body: {},
-                            status: httpError.status,
-                            message: httpError.error?.message || httpError.error,
-                            ok: false
+                            body: responseType == 'text' ? response : response.body,
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
                         });
-                    },
-                    complete: () => {
-                        this.ReleaseSubscription(subscription);
-                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                            this.alert.Success(request.alertSuccess);
-                        }
                     }
-                });
-            }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(subscription);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(subscription);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess);
+                    }
+                }
+            });
         });
     }
     /** HTTP POST */
     HTTP_POST(request, cancelPrevious = true) {
         return new Promise(Resolve => {
+            let subscription;
             if (cancelPrevious) {
-                this.ReleaseSubscription(this._POST$);
-                this._POST$ = this.http.request(new HttpRequest("POST", request.url, request.body, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: 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);
-                        }
-                    }
-                });
+                let subscription = this._POST$;
+                this.ReleaseSubscription(subscription);
             }
-            else {
-                const subscription = this.http.request(new HttpRequest("POST", request.url, request.body, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: response.body,
-                                status: response.status,
-                                message: response.statusText,
-                                ok: true
-                            });
-                        }
-                    },
-                    error: (httpError) => {
-                        this.ReleaseSubscription(subscription);
-                        this.AlertError(httpError, request.alertError);
+            const responseType = request?.responseType || 'json';
+            subscription = this.http.request(new HttpRequest("POST", request.url, request.body, {
+                params: request.queryParams,
+                headers: request.headers,
+                responseType: responseType,
+                withCredentials: request.withCredentials
+            })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
                         Resolve({
-                            body: {},
-                            status: httpError.status,
-                            message: httpError.error?.message || httpError.error,
-                            ok: false
+                            body: responseType == 'text' ? response : response.body,
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
                         });
-                    },
-                    complete: () => {
-                        this.ReleaseSubscription(subscription);
-                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                            this.alert.Success(request.alertSuccess);
-                        }
                     }
-                });
-            }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(subscription);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(subscription);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess);
+                    }
+                }
+            });
         });
     }
     /** HTTP PUT */
     HTTP_PUT(request, cancelPrevious = true) {
         return new Promise(Resolve => {
+            let subscription;
             if (cancelPrevious) {
-                this.ReleaseSubscription(this._PUT$);
-                this._PUT$ = this.http.request(new HttpRequest("PUT", request.url, request.body, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).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');
-                        }
-                    }
-                });
+                let subscription = this._PUT$;
+                this.ReleaseSubscription(subscription);
             }
-            else {
-                const subscription = this.http.request(new HttpRequest("PUT", request.url, request.body, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: {},
-                                status: response.status,
-                                message: response.statusText,
-                                ok: true
-                            });
-                        }
-                    },
-                    error: (httpError) => {
-                        this.ReleaseSubscription(subscription);
-                        this.AlertError(httpError, request.alertError);
+            const responseType = request?.responseType || 'json';
+            subscription = this.http.request(new HttpRequest("PUT", request.url, request.body, {
+                params: request.queryParams,
+                headers: request.headers,
+                responseType: responseType,
+                withCredentials: request.withCredentials
+            })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
                         Resolve({
-                            body: {},
-                            status: httpError.status,
-                            message: httpError.error?.message || httpError.error,
-                            ok: false
+                            body: responseType == 'text' ? response : {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
                         });
-                    },
-                    complete: () => {
-                        this.ReleaseSubscription(subscription);
-                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
-                        }
                     }
-                });
-            }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(subscription);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(subscription);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                    }
+                }
+            });
         });
     }
     /** HTTP PATCH */
     HTTP_PATCH(request, cancelPrevious = true) {
         return new Promise(Resolve => {
+            let subscription;
             if (cancelPrevious) {
-                this.ReleaseSubscription(this._PATCH$);
-                this._PATCH$ = this.http.request(new HttpRequest("PATCH", request.url, request.body, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).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');
-                        }
-                    }
-                });
+                let subscription = this._PATCH$;
+                this.ReleaseSubscription(subscription);
             }
-            else {
-                const subscription = this.http.request(new HttpRequest("PATCH", request.url, request.body, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: {},
-                                status: response.status,
-                                message: response.statusText,
-                                ok: true
-                            });
-                        }
-                    },
-                    error: (httpError) => {
-                        this.ReleaseSubscription(subscription);
-                        this.AlertError(httpError, request.alertError);
+            const responseType = request?.responseType || 'json';
+            subscription = this.http.request(new HttpRequest("PATCH", request.url, request.body, {
+                params: request.queryParams,
+                headers: request.headers,
+                responseType: responseType,
+                withCredentials: request.withCredentials
+            })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
                         Resolve({
-                            body: {},
-                            status: httpError.status,
-                            message: httpError.error?.message || httpError.error,
-                            ok: false
+                            body: responseType == 'text' ? response : {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
                         });
-                    },
-                    complete: () => {
-                        this.ReleaseSubscription(subscription);
-                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
-                        }
                     }
-                });
-            }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(subscription);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(subscription);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                    }
+                }
+            });
         });
     }
     /** HTTP DELETE */
     HTTP_DELETE(request, cancelPrevious = true) {
         return new Promise(Resolve => {
+            let subscription;
             if (cancelPrevious) {
-                this.ReleaseSubscription(this._DELETE$);
-                this._DELETE$ = this.http.request(new HttpRequest("DELETE", request.url, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).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');
-                        }
-                    }
-                });
+                let subscription = this._DELETE$;
+                this.ReleaseSubscription(subscription);
             }
-            else {
-                const subscription = this.http.request(new HttpRequest("DELETE", request.url, {
-                    params: request.queryParams,
-                    headers: request.headers,
-                    responseType: request.responseType,
-                    withCredentials: request.withCredentials
-                })).subscribe({
-                    next: (response) => {
-                        if (response.type > 0) {
-                            Resolve({
-                                body: {},
-                                status: response.status,
-                                message: response.statusText,
-                                ok: true
-                            });
-                        }
-                    },
-                    error: (httpError) => {
-                        this.ReleaseSubscription(subscription);
-                        this.AlertError(httpError, request.alertError);
+            const responseType = request?.responseType || 'json';
+            subscription = this.http.request(new HttpRequest("DELETE", request.url, {
+                params: request.queryParams,
+                headers: request.headers,
+                responseType: responseType,
+                withCredentials: request.withCredentials
+            })).subscribe({
+                next: (response) => {
+                    if (response.type > 0) {
                         Resolve({
-                            body: {},
-                            status: httpError.status,
-                            message: httpError.error?.message || httpError.error,
-                            ok: false
+                            body: responseType == 'text' ? response : {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
                         });
-                    },
-                    complete: () => {
-                        this.ReleaseSubscription(subscription);
-                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                            this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
-                        }
                     }
-                });
-            }
+                },
+                error: (httpError) => {
+                    this.ReleaseSubscription(subscription);
+                    this.AlertError(httpError, request.alertError);
+                    Resolve({
+                        body: {},
+                        status: httpError.status,
+                        message: httpError.error?.message || httpError.error,
+                        ok: false
+                    });
+                },
+                complete: () => {
+                    this.ReleaseSubscription(subscription);
+                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                        this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
+                    }
+                }
+            });
         });
     }
     /** */