@inobeta/ui 18.0.1-build.1722007687

package/README.md

@@ -0,0 +1 @@
+For usage information, refer  to the [documentation](https://ui-docs.inobeta.net/current/?path=/docs/getting-started--docs)

package/_index.scss

@@ -0,0 +1 @@
+@forward './src/app/inobeta-ui/ui'

package/esm2022/inobeta-ui.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5vYmV0YS11aS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2lub2JldGEtdWkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2022/public_api.mjs

@@ -0,0 +1,17 @@
+export * from './src/app/inobeta-ui/core';
+export * from './src/app/inobeta-ui/http/index';
+export * from './src/app/inobeta-ui/hydration/index';
+export * from './src/app/inobeta-ui/storage/index';
+export * from './src/app/inobeta-ui/translate/index';
+export * from './src/app/inobeta-ui/ui/breadcrumb/index';
+export * from './src/app/inobeta-ui/ui/data-export/index';
+export * from './src/app/inobeta-ui/ui/forms/index';
+export * from './src/app/inobeta-ui/ui/kai-filter/index';
+export * from './src/app/inobeta-ui/ui/kai-table/index';
+export * from './src/app/inobeta-ui/ui/main-menu/index';
+export * from './src/app/inobeta-ui/ui/material-forms/index';
+export * from './src/app/inobeta-ui/ui/modal/index';
+export * from './src/app/inobeta-ui/ui/toast/index';
+export * from './src/app/inobeta-ui/ui/uploader/index';
+export * from './src/app/inobeta-ui/ui/views/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3JjL2FwcC9pbm9iZXRhLXVpL2NvcmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvaHR0cC9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcHAvaW5vYmV0YS11aS9oeWRyYXRpb24vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvc3RvcmFnZS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcHAvaW5vYmV0YS11aS90cmFuc2xhdGUvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvdWkvYnJlYWRjcnVtYi9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcHAvaW5vYmV0YS11aS91aS9kYXRhLWV4cG9ydC9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcHAvaW5vYmV0YS11aS91aS9mb3Jtcy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcHAvaW5vYmV0YS11aS91aS9rYWktZmlsdGVyL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2FwcC9pbm9iZXRhLXVpL3VpL2thaS10YWJsZS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hcHAvaW5vYmV0YS11aS91aS9tYWluLW1lbnUvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvdWkvbWF0ZXJpYWwtZm9ybXMvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvdWkvbW9kYWwvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvdWkvdG9hc3QvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvdWkvdXBsb2FkZXIvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXBwL2lub2JldGEtdWkvdWkvdmlld3MvaW5kZXgnO1xuXG5cbiJdfQ==

package/esm2022/src/app/inobeta-ui/core/filter.pipe.mjs

@@ -0,0 +1,23 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class IbFilterPipe {
+    transform(items, query) {
+        if (!items) {
+            return [];
+        }
+        if (!query) {
+            return items;
+        }
+        return items.filter((i) => i.toLocaleLowerCase().includes(query.toLocaleLowerCase()));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbFilterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: IbFilterPipe, isStandalone: true, name: "filterBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbFilterPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "filterBy",
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2lub2JldGEtdWkvY29yZS9maWx0ZXIucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFNcEQsTUFBTSxPQUFPLFlBQVk7SUFDdkIsU0FBUyxDQUFDLEtBQWUsRUFBRSxLQUFhO1FBQ3RDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNYLE9BQU8sRUFBRSxDQUFDO1FBQ1osQ0FBQztRQUVELElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNYLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQ3hCLENBQUMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsaUJBQWlCLEVBQUUsQ0FBQyxDQUMxRCxDQUFDO0lBQ0osQ0FBQzt1R0FiVSxZQUFZO3FHQUFaLFlBQVk7OzJGQUFaLFlBQVk7a0JBSnhCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLFVBQVU7b0JBQ2hCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5AUGlwZSh7XG4gIG5hbWU6IFwiZmlsdGVyQnlcIixcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgSWJGaWx0ZXJQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybShpdGVtczogc3RyaW5nW10sIHF1ZXJ5OiBzdHJpbmcpOiBzdHJpbmdbXSB7XG4gICAgaWYgKCFpdGVtcykge1xuICAgICAgcmV0dXJuIFtdO1xuICAgIH1cblxuICAgIGlmICghcXVlcnkpIHtcbiAgICAgIHJldHVybiBpdGVtcztcbiAgICB9XG5cbiAgICByZXR1cm4gaXRlbXMuZmlsdGVyKChpKSA9PlxuICAgICAgaS50b0xvY2FsZUxvd2VyQ2FzZSgpLmluY2x1ZGVzKHF1ZXJ5LnRvTG9jYWxlTG93ZXJDYXNlKCkpXG4gICAgKTtcbiAgfVxufVxuIl19

package/esm2022/src/app/inobeta-ui/core/index.mjs

@@ -0,0 +1,2 @@
+export * from "./filter.pipe";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2lub2JldGEtdWkvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlci5waXBlXCI7XG4iXX0=

package/esm2022/src/app/inobeta-ui/http/auth/guard.service.mjs

@@ -0,0 +1,157 @@
+import { Inject, Injectable, inject } from "@angular/core";
+import { Store } from "@ngrx/store";
+import { map, take } from "rxjs/operators";
+import { ibSelectActiveSession } from "../store/session/selectors";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./login.service";
+/**
+ * Guard routes based on user authentication.
+ *
+ * Usage:
+ * - Include the `IbAuthGuard` in the `canActivate` route guard to protect routes.
+ * - If the user is not authenticated, they will be redirected to the login page provided by the `ibHttpGUILoginUrl` token.
+ *
+ * Example:
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'dashboard',
+ *     component: DashboardComponent,
+ *     canActivate: [IbAuthGuard],
+ *   },
+ *   // ... other routes ...
+ * ];
+ * ```
+ */
+export class IbAuthGuard {
+    router;
+    ibHttpGUILoginUrl;
+    store = inject(Store);
+    session$ = this.store.select(ibSelectActiveSession());
+    constructor(router, ibHttpGUILoginUrl) {
+        this.router = router;
+        this.ibHttpGUILoginUrl = ibHttpGUILoginUrl;
+    }
+    canActivate() {
+        return this.session$.pipe(take(1), map((session) => {
+            const isAuth = session != null;
+            if (!isAuth) {
+                this.router.navigateByUrl(this.ibHttpGUILoginUrl);
+            }
+            return isAuth;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAuthGuard, deps: [{ token: i1.Router }, { token: "ibHttpGUILoginUrl" }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAuthGuard, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAuthGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpGUILoginUrl"]
+                }] }] });
+/**
+ * Guard routes based on user login status.
+ * The opposite of IbAuthGuard, the route will activate if a user is NOT authenticated
+ *
+ * Usage:
+ * - Include the `IbLoginGuard` in the `canActivate` route guard to protect routes.
+ * - If the user is authenticated, they will be redirected to a page provided by the `ibHttpGUIDashboardUrl` token
+ *
+ * Example:
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'login',
+ *     component: LoginComponent,
+ *     canActivate: [IbLoginGuard],
+ *   },
+ *   // ... other routes ...
+ * ];
+ * ```
+ */
+export class IbLoginGuard {
+    router;
+    ibHttpGUIDashboardUrl;
+    store = inject(Store);
+    session$ = this.store.select(ibSelectActiveSession());
+    path = "";
+    constructor(router, ibHttpGUIDashboardUrl) {
+        this.router = router;
+        this.ibHttpGUIDashboardUrl = ibHttpGUIDashboardUrl;
+    }
+    canActivate() {
+        return this.session$.pipe(take(1), map((session) => {
+            const isAuth = session != null;
+            if (isAuth) {
+                if (this.path !== "") {
+                    this.router.navigateByUrl(this.path);
+                }
+                else {
+                    this.router.navigateByUrl(this.ibHttpGUIDashboardUrl);
+                }
+            }
+            return !isAuth;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginGuard, deps: [{ token: i1.Router }, { token: "ibHttpGUIDashboardUrl" }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginGuard, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpGUIDashboardUrl"]
+                }] }] });
+/**
+ * Guard routes based on user roles.
+ *
+ * Usage:
+ * - Include the `IbRoleGuard` in the `canActivate` route guard to protect routes based on user roles.
+ * - Specify the required roles in the route's data property.
+ * - If the user is not granted access, they will be redirected to a page provided by the `ibHttpGUIDashboardUrl` token
+ *
+ * Example:
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'admin',
+ *     component: AdminComponent,
+ *     canActivate: [IbRoleGuard],
+ *     data: { roles: ['admin'] }
+ *   },
+ *   // ... other routes ...
+ * ];
+ * ```
+ */
+export class IbRoleGuard {
+    router;
+    login;
+    ibHttpGUIDashboardUrl;
+    constructor(router, login, ibHttpGUIDashboardUrl) {
+        this.router = router;
+        this.login = login;
+        this.ibHttpGUIDashboardUrl = ibHttpGUIDashboardUrl;
+    }
+    canActivate(route) {
+        return this.login.hasRoles(route.data.roles).pipe(take(1), map((hasRole) => {
+            if (!hasRole) {
+                this.router.navigateByUrl(this.ibHttpGUIDashboardUrl);
+            }
+            return hasRole;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbRoleGuard, deps: [{ token: i1.Router }, { token: i2.IbLoginService }, { token: "ibHttpGUIDashboardUrl" }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbRoleGuard, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbRoleGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.IbLoginService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpGUIDashboardUrl"]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guard.service.js","sourceRoot":"","sources":["../../../../../../../src/app/inobeta-ui/http/auth/guard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional, inject } from \"@angular/core\";\nimport { ActivatedRouteSnapshot, Router } from \"@angular/router\";\nimport { Store } from \"@ngrx/store\";\nimport { Observable } from \"rxjs\";\nimport { map, take } from \"rxjs/operators\";\nimport { ibSelectActiveSession } from \"../store/session/selectors\";\nimport { IbLoginService } from \"./login.service\";\nimport { IbAPITokens, IbSession } from \"./session.model\";\n\n/**\n * Guard routes based on user authentication.\n *\n * Usage:\n * - Include the `IbAuthGuard` in the `canActivate` route guard to protect routes.\n * - If the user is not authenticated, they will be redirected to the login page provided by the `ibHttpGUILoginUrl` token.\n *\n * Example:\n * ```typescript\n * const routes: Routes = [\n *   {\n *     path: 'dashboard',\n *     component: DashboardComponent,\n *     canActivate: [IbAuthGuard],\n *   },\n *   // ... other routes ...\n * ];\n * ```\n */\n@Injectable({ providedIn: \"root\" })\nexport class IbAuthGuard {\n  store = inject(Store);\n  session$: Observable<IbSession<IbAPITokens> | null> = this.store.select(\n    ibSelectActiveSession<IbAPITokens>()\n  );\n\n  constructor(\n    private router: Router,\n    @Inject(\"ibHttpGUILoginUrl\") public ibHttpGUILoginUrl: string\n  ) {}\n\n  canActivate() {\n    return this.session$.pipe(\n      take(1),\n      map((session) => {\n        const isAuth = session != null;\n        if (!isAuth) {\n          this.router.navigateByUrl(this.ibHttpGUILoginUrl);\n        }\n        return isAuth;\n      })\n    );\n  }\n}\n\n/**\n * Guard routes based on user login status.\n * The opposite of IbAuthGuard, the route will activate if a user is NOT authenticated\n *\n * Usage:\n * - Include the `IbLoginGuard` in the `canActivate` route guard to protect routes.\n * - If the user is authenticated, they will be redirected to a page provided by the `ibHttpGUIDashboardUrl` token\n *\n * Example:\n * ```typescript\n * const routes: Routes = [\n *   {\n *     path: 'login',\n *     component: LoginComponent,\n *     canActivate: [IbLoginGuard],\n *   },\n *   // ... other routes ...\n * ];\n * ```\n */\n@Injectable({ providedIn: \"root\" })\nexport class IbLoginGuard {\n  store = inject(Store);\n  session$: Observable<IbSession<IbAPITokens> | null> = this.store.select(\n    ibSelectActiveSession<IbAPITokens>()\n  );\n\n  public path = \"\";\n  constructor(\n    private router: Router,\n    @Inject(\"ibHttpGUIDashboardUrl\")\n    public ibHttpGUIDashboardUrl: string\n  ) {}\n\n  canActivate() {\n    return this.session$.pipe(\n      take(1),\n      map((session) => {\n        const isAuth = session != null;\n        if (isAuth) {\n          if (this.path !== \"\") {\n            this.router.navigateByUrl(this.path);\n          } else {\n            this.router.navigateByUrl(this.ibHttpGUIDashboardUrl);\n          }\n        }\n        return !isAuth;\n      })\n    );\n  }\n}\n\n/**\n * Guard routes based on user roles.\n *\n * Usage:\n * - Include the `IbRoleGuard` in the `canActivate` route guard to protect routes based on user roles.\n * - Specify the required roles in the route's data property.\n * - If the user is not granted access, they will be redirected to a page provided by the `ibHttpGUIDashboardUrl` token\n *\n * Example:\n * ```typescript\n * const routes: Routes = [\n *   {\n *     path: 'admin',\n *     component: AdminComponent,\n *     canActivate: [IbRoleGuard],\n *     data: { roles: ['admin'] }\n *   },\n *   // ... other routes ...\n * ];\n * ```\n */\n@Injectable({ providedIn: \"root\" })\nexport class IbRoleGuard {\n  constructor(\n    private router: Router,\n    private login: IbLoginService<IbAPITokens>,\n    @Inject(\"ibHttpGUIDashboardUrl\")\n    public ibHttpGUIDashboardUrl: string\n  ) {}\n\n  canActivate(route: ActivatedRouteSnapshot) {\n    return this.login.hasRoles(route.data.roles).pipe(\n      take(1),\n      map((hasRole) => {\n        if (!hasRole) {\n          this.router.navigateByUrl(this.ibHttpGUIDashboardUrl);\n        }\n        return hasRole;\n      })\n    );\n  }\n}\n"]}

package/esm2022/src/app/inobeta-ui/http/auth/login.service.mjs

@@ -0,0 +1,137 @@
+import { Inject, Injectable } from "@angular/core";
+import { jwtDecode } from "jwt-decode";
+import { throwError } from "rxjs";
+import { catchError, filter, map } from "rxjs/operators";
+import { ibAuthActions } from "../store/session/actions";
+import { ibSelectActiveSession } from "../store/session/selectors";
+import { IbAuthTypes, IbSession, } from "./session.model";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/material/snack-bar";
+export class IbLoginService {
+    httpClient;
+    store;
+    srvRouter;
+    snackBar;
+    ibHttpGUILoginUrl;
+    ibHttpAPILoginUrl;
+    ibHttpAuthType;
+    ibHttpSessionStorageType;
+    ibHttpAPIRefreshUrl;
+    ibHttpJWTClaimsField;
+    ibHttpJWTRolesField;
+    constructor(httpClient, store, srvRouter, snackBar, 
+    /** Login page path */
+    ibHttpGUILoginUrl, 
+    /** API login endpoint */
+    ibHttpAPILoginUrl, 
+    /** Authorizazion type. Either bearer token (JWT) or basic */
+    ibHttpAuthType, 
+    /** Where to storage the user's access token */
+    ibHttpSessionStorageType, 
+    /** Refresh access token API endpoint */
+    ibHttpAPIRefreshUrl, 
+    /** Property name of additional data or claims within the JWT token */
+    ibHttpJWTClaimsField, 
+    /** Property name of the user roles within the JWT claims field */
+    ibHttpJWTRolesField) {
+        this.httpClient = httpClient;
+        this.store = store;
+        this.srvRouter = srvRouter;
+        this.snackBar = snackBar;
+        this.ibHttpGUILoginUrl = ibHttpGUILoginUrl;
+        this.ibHttpAPILoginUrl = ibHttpAPILoginUrl;
+        this.ibHttpAuthType = ibHttpAuthType;
+        this.ibHttpSessionStorageType = ibHttpSessionStorageType;
+        this.ibHttpAPIRefreshUrl = ibHttpAPIRefreshUrl;
+        this.ibHttpJWTClaimsField = ibHttpJWTClaimsField;
+        this.ibHttpJWTRolesField = ibHttpJWTRolesField;
+    }
+    /**
+     * Attempts a login to the server by contacting the endpoint provided by the token {@link ibHttpAPILoginUrl}
+     */
+    login(user) {
+        const activeSession = new IbSession();
+        if (user) {
+            if (this.ibHttpAuthType === IbAuthTypes.BASIC_AUTH) {
+                activeSession.serverData.accessToken = window.btoa(user.email + ":" + user.password);
+            }
+            activeSession.valid = false;
+            activeSession.user = {
+                ...user,
+                password: "",
+            };
+        }
+        return this.httpClient.post(this.ibHttpAPILoginUrl, user).pipe(map((token) => {
+            activeSession.valid = true;
+            activeSession.serverData = token;
+            this.store.dispatch(ibAuthActions.login({ activeSession: activeSession }));
+            return token;
+        }), catchError((err) => throwError(() => err)));
+    }
+    /**
+     * Refresh a token by contacting the endpoint provided by the token {@link ibHttpAPIRefreshUrl}
+     */
+    refresh(token) {
+        return this.httpClient.post(this.ibHttpAPIRefreshUrl, {
+            token,
+        });
+    }
+    /**
+     * Logout the user, clear the session, and navigate back to {@link ibHttpGUILoginUrl}
+     * @param makeSnack Whether to show a snackbar message when logging out
+     */
+    logout(makeSnack = true) {
+        this.store.dispatch(ibAuthActions.logout());
+        this.srvRouter.navigateByUrl(this.ibHttpGUILoginUrl);
+        if (makeSnack) {
+            this.snackBar.open("Logout completed", null, { duration: 2000 });
+        }
+    }
+    /**
+     * Check whether the current user has at least one of the provided roles
+     * @param roles List of roles
+     * @returns true if the user has at least one of the provided roles
+     */
+    hasRoles(roles) {
+        return this.store.select(ibSelectActiveSession()).pipe(filter((session) => session?.serverData?.accessToken !== undefined), map((session) => jwtDecode(session.serverData.accessToken)), map((decodedData) => {
+            const userRoles = decodedData?.[this.ibHttpJWTClaimsField]?.[this.ibHttpJWTRolesField] ?? [];
+            for (let r of roles) {
+                if (userRoles.findIndex((ur) => ur === r) >= 0) {
+                    return true;
+                }
+            }
+            return false;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginService, deps: [{ token: i1.HttpClient }, { token: i2.Store }, { token: i3.Router }, { token: i4.MatSnackBar }, { token: "ibHttpGUILoginUrl" }, { token: "ibHttpAPILoginUrl" }, { token: "ibHttpAuthType" }, { token: "ibHttpSessionStorageType" }, { token: "ibHttpAPIRefreshUrl" }, { token: "ibHttpJWTClaimsField" }, { token: "ibHttpJWTRolesField" }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.Store }, { type: i3.Router }, { type: i4.MatSnackBar }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpGUILoginUrl"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpAPILoginUrl"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpAuthType"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpSessionStorageType"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpAPIRefreshUrl"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpJWTClaimsField"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpJWTRolesField"]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login.service.js","sourceRoot":"","sources":["../../../../../../../src/app/inobeta-ui/http/auth/login.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\nimport { Inject, Injectable } from \"@angular/core\";\nimport { MatSnackBar } from \"@angular/material/snack-bar\";\nimport { Router } from \"@angular/router\";\nimport { Store } from \"@ngrx/store\";\nimport { jwtDecode } from \"jwt-decode\";\nimport { Observable, throwError } from \"rxjs\";\nimport { catchError, filter, map } from \"rxjs/operators\";\nimport { ibAuthActions } from \"../store/session/actions\";\nimport { ibSelectActiveSession } from \"../store/session/selectors\";\nimport {\n  IbAPITokens,\n  IbAuthTypes,\n  IbSession,\n  IbUserLogin,\n} from \"./session.model\";\n\n@Injectable({ providedIn: \"root\" })\nexport class IbLoginService<T extends IbAPITokens | IbAPITokens> {\n  constructor(\n    private httpClient: HttpClient,\n    private store: Store,\n    private srvRouter: Router,\n    private snackBar: MatSnackBar,\n    /** Login page path */\n    @Inject(\"ibHttpGUILoginUrl\")\n    public ibHttpGUILoginUrl,\n    /** API login endpoint */\n    @Inject(\"ibHttpAPILoginUrl\")\n    public ibHttpAPILoginUrl,\n    /** Authorizazion type. Either bearer token (JWT) or basic */\n    @Inject(\"ibHttpAuthType\")\n    public ibHttpAuthType,\n    /** Where to storage the user's access token */\n    @Inject(\"ibHttpSessionStorageType\")\n    public ibHttpSessionStorageType,\n    /** Refresh access token API endpoint */\n    @Inject(\"ibHttpAPIRefreshUrl\")\n    public ibHttpAPIRefreshUrl,\n    /** Property name of additional data or claims within the JWT token */\n    @Inject(\"ibHttpJWTClaimsField\")\n    public ibHttpJWTClaimsField,\n    /** Property name of the user roles within the JWT claims field */\n    @Inject(\"ibHttpJWTRolesField\")\n    public ibHttpJWTRolesField\n  ) {}\n\n  /**\n   * Attempts a login to the server by contacting the endpoint provided by the token {@link ibHttpAPILoginUrl}\n   */\n  public login(user: IbUserLogin) {\n    const activeSession = new IbSession<T>();\n\n    if (user) {\n      if (this.ibHttpAuthType === IbAuthTypes.BASIC_AUTH) {\n        activeSession.serverData.accessToken = window.btoa(\n          user.email + \":\" + user.password\n        );\n      }\n      activeSession.valid = false;\n      activeSession.user = {\n        ...user,\n        password: \"\",\n      };\n    }\n\n    return this.httpClient.post<T>(this.ibHttpAPILoginUrl, user).pipe(\n      map((token) => {\n        activeSession.valid = true;\n        activeSession.serverData = token;\n        this.store.dispatch(\n          ibAuthActions.login({ activeSession: activeSession })\n        );\n        return token;\n      }),\n      catchError((err) => throwError(() => err))\n    );\n  }\n\n  /**\n   * Refresh a token by contacting the endpoint provided by the token {@link ibHttpAPIRefreshUrl}\n   */\n  public refresh(token: string) {\n    return this.httpClient.post<IbAPITokens>(this.ibHttpAPIRefreshUrl, {\n      token,\n    });\n  }\n\n  /**\n   * Logout the user, clear the session, and navigate back to {@link ibHttpGUILoginUrl}\n   * @param makeSnack Whether to show a snackbar message when logging out\n   */\n  public logout(makeSnack: boolean = true) {\n    this.store.dispatch(ibAuthActions.logout());\n    this.srvRouter.navigateByUrl(this.ibHttpGUILoginUrl);\n    if (makeSnack) {\n      this.snackBar.open(\"Logout completed\", null, { duration: 2000 });\n    }\n  }\n\n  /**\n   * Check whether the current user has at least one of the provided roles\n   * @param roles List of roles\n   * @returns true if the user has at least one of the provided roles\n   */\n  public hasRoles(roles: string[]): Observable<boolean> {\n    return this.store.select(ibSelectActiveSession<IbAPITokens>()).pipe(\n      filter((session) => session?.serverData?.accessToken !== undefined),\n      map((session) => jwtDecode(session.serverData.accessToken)),\n      map((decodedData) => {\n        const userRoles: string[] =\n          decodedData?.[this.ibHttpJWTClaimsField]?.[\n            this.ibHttpJWTRolesField\n          ] ?? [];\n        for (let r of roles) {\n          if (userRoles.findIndex((ur) => ur === r) >= 0) {\n            return true;\n          }\n        }\n        return false;\n      })\n    );\n  }\n}\n"]}

package/esm2022/src/app/inobeta-ui/http/auth/login.service.stub.spec.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from "@angular/core";
+import { of } from "rxjs";
+import * as i0 from "@angular/core";
+export class IbLoginServiceStub {
+    login(u) {
+        return of({
+            accessToken: '',
+            refreshToken: ''
+        });
+    }
+    logout() {
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginServiceStub, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginServiceStub, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbLoginServiceStub, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9naW4uc2VydmljZS5zdHViLnNwZWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2lub2JldGEtdWkvaHR0cC9hdXRoL2xvZ2luLnNlcnZpY2Uuc3R1Yi5zcGVjLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFLdEMsTUFBTSxPQUFPLGtCQUFrQjtJQUU3QixLQUFLLENBQUUsQ0FBYztRQUNuQixPQUFPLEVBQUUsQ0FBQztZQUNSLFdBQVcsRUFBRSxFQUFFO1lBQ2YsWUFBWSxFQUFFLEVBQUU7U0FDakIsQ0FBa0IsQ0FBQTtJQUNyQixDQUFDO0lBRUQsTUFBTTtJQUNOLENBQUM7dUdBVlUsa0JBQWtCOzJHQUFsQixrQkFBa0IsY0FETixNQUFNOzsyRkFDbEIsa0JBQWtCO2tCQUQ5QixVQUFVO21CQUFDLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tIFwicnhqc1wiO1xuaW1wb3J0IHsgSWJBUElUb2tlbnMsIEliVXNlckxvZ2luIH0gZnJvbSBcIi4vc2Vzc2lvbi5tb2RlbFwiO1xuXG5cbkBJbmplY3RhYmxlKHtwcm92aWRlZEluOiAncm9vdCd9KVxuZXhwb3J0IGNsYXNzIEliTG9naW5TZXJ2aWNlU3R1YjxUIGV4dGVuZHMgSWJBUElUb2tlbnMgfCBJYkFQSVRva2VucyA+IHtcblxuICBsb2dpbiAodTogSWJVc2VyTG9naW4pOiBPYnNlcnZhYmxlPFQ+e1xuICAgIHJldHVybiBvZih7XG4gICAgICBhY2Nlc3NUb2tlbjogJycsXG4gICAgICByZWZyZXNoVG9rZW46ICcnXG4gICAgfSkgYXMgT2JzZXJ2YWJsZTxUPlxuICB9XG5cbiAgbG9nb3V0KCkge1xuICB9XG5cbn1cbiJdfQ==

package/esm2022/src/app/inobeta-ui/http/auth/session.model.mjs

@@ -0,0 +1,16 @@
+export class IbSession {
+    user;
+    valid;
+    serverData;
+}
+export class IbUserLogin {
+    email;
+    password;
+    rememberMe;
+}
+export var IbAuthTypes;
+(function (IbAuthTypes) {
+    IbAuthTypes[IbAuthTypes["BASIC_AUTH"] = 0] = "BASIC_AUTH";
+    IbAuthTypes[IbAuthTypes["JWT"] = 1] = "JWT";
+})(IbAuthTypes || (IbAuthTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvaW5vYmV0YS11aS9odHRwL2F1dGgvc2Vzc2lvbi5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sU0FBUztJQUNwQixJQUFJLENBQWM7SUFDbEIsS0FBSyxDQUFVO0lBQ2YsVUFBVSxDQUFHO0NBQ2Q7QUFFRCxNQUFNLE9BQU8sV0FBVztJQUN0QixLQUFLLENBQVM7SUFDZCxRQUFRLENBQVM7SUFDakIsVUFBVSxDQUFVO0NBQ3JCO0FBRUQsTUFBTSxDQUFOLElBQVksV0FHWDtBQUhELFdBQVksV0FBVztJQUNyQix5REFBVSxDQUFBO0lBQ1YsMkNBQUcsQ0FBQTtBQUNMLENBQUMsRUFIVyxXQUFXLEtBQVgsV0FBVyxRQUd0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBJYlNlc3Npb248VCBleHRlbmRzIEliQVBJVG9rZW5zIHwgSWJBUElUb2tlbnM+IHtcbiAgdXNlcjogSWJVc2VyTG9naW47XG4gIHZhbGlkOiBib29sZWFuO1xuICBzZXJ2ZXJEYXRhOiBUXG59XG5cbmV4cG9ydCBjbGFzcyBJYlVzZXJMb2dpbiB7XG4gIGVtYWlsOiBzdHJpbmc7XG4gIHBhc3N3b3JkOiBzdHJpbmc7XG4gIHJlbWVtYmVyTWU6IGJvb2xlYW47XG59XG5cbmV4cG9ydCBlbnVtIEliQXV0aFR5cGVzIHtcbiAgQkFTSUNfQVVUSCxcbiAgSldUXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSWJBUElUb2tlbnMge1xuICBhY2Nlc3NUb2tlbjogc3RyaW5nO1xuICByZWZyZXNoVG9rZW46IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/src/app/inobeta-ui/http/http/auth.interceptor.mjs

@@ -0,0 +1,79 @@
+import { Inject, Injectable, inject } from "@angular/core";
+import { Store } from "@ngrx/store";
+import { throwError } from "rxjs";
+import { catchError, mergeMap, take } from "rxjs/operators";
+import { IbAuthTypes } from "../auth/session.model";
+import { ibSelectActiveSession } from "../store/session/selectors";
+import * as i0 from "@angular/core";
+import * as i1 from "../../ui/toast/toast.service";
+import * as i2 from "../auth/login.service";
+import * as i3 from "../auth/session.model";
+export class IbAuthInterceptor {
+    ibToast;
+    login;
+    ibHttpEnableInterceptors;
+    ibHttpAPILoginUrl;
+    ibHttpToastOnLoginFailure;
+    ibHttpAuthType;
+    store = inject(Store);
+    session$ = this.store.select(ibSelectActiveSession());
+    constructor(ibToast, login, ibHttpEnableInterceptors, ibHttpAPILoginUrl, ibHttpToastOnLoginFailure, ibHttpAuthType) {
+        this.ibToast = ibToast;
+        this.login = login;
+        this.ibHttpEnableInterceptors = ibHttpEnableInterceptors;
+        this.ibHttpAPILoginUrl = ibHttpAPILoginUrl;
+        this.ibHttpToastOnLoginFailure = ibHttpToastOnLoginFailure;
+        this.ibHttpAuthType = ibHttpAuthType;
+    }
+    intercept(request, next) {
+        let authString = "";
+        let authReq = request.clone({
+            headers: request.headers.set("x-requested-with", "XMLHttpRequest"),
+        });
+        switch (this.ibHttpAuthType) {
+            case IbAuthTypes.JWT:
+                authString = "Bearer ";
+                break;
+            case IbAuthTypes.BASIC_AUTH:
+                authString = "Basic ";
+                break;
+        }
+        return this.session$.pipe(take(1), mergeMap((session) => {
+            if (session?.valid && session?.serverData?.accessToken) {
+                authString += session.serverData.accessToken;
+                authReq = request.clone({
+                    headers: request.headers.set("Authorization", authString),
+                });
+            }
+            return next.handle(authReq);
+        }), catchError((err) => {
+            if (!this.ibHttpEnableInterceptors) {
+                return throwError(() => err);
+            }
+            if (request.url !== this.ibHttpAPILoginUrl && err.status === 401) {
+                this.ibToast.open(this.ibHttpToastOnLoginFailure, "warning");
+                this.login.logout(false);
+            }
+            return throwError(() => err);
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAuthInterceptor, deps: [{ token: i1.IbToastNotification }, { token: i2.IbLoginService }, { token: "ibHttpEnableInterceptors" }, { token: "ibHttpAPILoginUrl" }, { token: "ibHttpToastOnLoginFailure" }, { token: "ibHttpAuthType" }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAuthInterceptor, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAuthInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.IbToastNotification }, { type: i2.IbLoginService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpEnableInterceptors"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpAPILoginUrl"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpToastOnLoginFailure"]
+                }] }, { type: i3.IbAuthTypes, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpAuthType"]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/inobeta-ui/http/http/error.interceptor.mjs

@@ -0,0 +1,76 @@
+import { Inject, Injectable } from "@angular/core";
+import { throwError } from "rxjs";
+import { catchError } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "../../ui/toast/toast.service";
+import * as i2 from "@ngx-translate/core";
+export class IbErrorInterceptor {
+    ibToast;
+    translate;
+    ibHttpEnableInterceptors;
+    ibHttpToastOnGenericFailure;
+    ibHttpToastErrorField;
+    ibHttpToastOnStatusCode;
+    ibHttpToastErrorCode;
+    constructor(ibToast, translate, ibHttpEnableInterceptors, ibHttpToastOnGenericFailure, ibHttpToastErrorField, ibHttpToastOnStatusCode, ibHttpToastErrorCode) {
+        this.ibToast = ibToast;
+        this.translate = translate;
+        this.ibHttpEnableInterceptors = ibHttpEnableInterceptors;
+        this.ibHttpToastOnGenericFailure = ibHttpToastOnGenericFailure;
+        this.ibHttpToastErrorField = ibHttpToastErrorField;
+        this.ibHttpToastOnStatusCode = ibHttpToastOnStatusCode;
+        this.ibHttpToastErrorCode = ibHttpToastErrorCode;
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError((err) => {
+            if (!this.ibHttpEnableInterceptors) {
+                return throwError(() => err);
+            }
+            if ([200, 401].indexOf(err.status) === -1) {
+                let errorMessage = this.ibHttpToastOnGenericFailure;
+                if (this.ibHttpToastOnStatusCode[err.status]) {
+                    errorMessage = this.ibHttpToastOnStatusCode[err.status];
+                }
+                if (this.ibHttpToastErrorField &&
+                    err.error &&
+                    err.error[this.ibHttpToastErrorField]) {
+                    errorMessage = err.error[this.ibHttpToastErrorField];
+                }
+                if (this.ibHttpToastErrorCode &&
+                    err.error &&
+                    err.error[this.ibHttpToastErrorCode]) {
+                    const codeError = `shared.ibHttp.error${err.error[this.ibHttpToastErrorCode]}`;
+                    const instant = this.translate.instant(codeError);
+                    if (instant !==
+                        `shared.ibHttp.error${err.error[this.ibHttpToastErrorCode]}`) {
+                        errorMessage = instant;
+                    }
+                }
+                this.ibToast.open(errorMessage, "error");
+            }
+            return throwError(() => err);
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbErrorInterceptor, deps: [{ token: i1.IbToastNotification }, { token: i2.TranslateService }, { token: "ibHttpEnableInterceptors" }, { token: "ibHttpToastOnGenericFailure" }, { token: "ibHttpToastErrorField" }, { token: "ibHttpToastOnStatusCode" }, { token: "ibHttpToastErrorCode" }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbErrorInterceptor, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbErrorInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.IbToastNotification }, { type: i2.TranslateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpEnableInterceptors"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpToastOnGenericFailure"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpToastErrorField"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpToastOnStatusCode"]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["ibHttpToastErrorCode"]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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