@c8y/ngx-components 1021.66.0 → 1021.70.1

package/esm2022/messaging-management/messaging/topic/topics-data-grid.service.mjs

@@ -0,0 +1,113 @@
+import { inject, Injectable } from '@angular/core';
+import { BaseColumn, gettext } from '@c8y/ngx-components';
+import { MessagingTopicsService } from '../../api/services/messaging-topics.service';
+import * as i0 from "@angular/core";
+export class TopicsDataGridService {
+    constructor() {
+        this.topicsService = inject(MessagingTopicsService);
+    }
+    getColumns() {
+        return [
+            this.createColumn({
+                name: 'name',
+                header: gettext('Name'),
+                path: 'name',
+                filterable: true,
+                filteringConfig: {
+                    fields: [
+                        {
+                            key: 'name',
+                            type: 'input',
+                            props: {
+                                label: gettext('Filter topics by partial name'),
+                                placeholder: 'myTopic',
+                                required: true
+                            }
+                        }
+                    ],
+                    getFilter(model) {
+                        return model.name;
+                    }
+                }
+            }),
+            this.createColumn({
+                name: 'msgRateIn',
+                header: gettext('Message rate in (msg/s)'),
+                path: 'msgRateIn'
+            }),
+            this.createColumn({
+                name: 'msgRateOut',
+                header: gettext('Message rate out (msg/s)'),
+                path: 'msgRateOut'
+            }),
+            this.createColumn({
+                name: 'subscribers',
+                header: gettext('Subscribers'),
+                path: 'subscribers'
+            }),
+            this.createColumn({
+                name: 'backlogSize',
+                header: gettext('Message backlog'),
+                path: 'backlogSize'
+            }),
+            this.createColumn({
+                name: 'backlogUsagePercentage',
+                header: gettext('Used backlog'),
+                path: 'backlogUsagePercentage',
+                sortOrder: 'desc'
+            })
+        ];
+    }
+    async getServerSideData(tenantId, namespaceId, dataSourceModifier) {
+        const topicFilters = this.getTopicFilters(tenantId, namespaceId, dataSourceModifier);
+        const { res, data, paging } = await this.topicsService.list(topicFilters);
+        const filteredSize = paging.totalElements;
+        const size = (await this.topicsService.list({
+            ...topicFilters,
+            currentPage: 1,
+            pageSize: 1
+        })).paging.totalPages;
+        return {
+            res,
+            data,
+            paging,
+            size,
+            filteredSize
+        };
+    }
+    createColumn(columnProps) {
+        const column = new BaseColumn();
+        Object.assign(column, columnProps);
+        return column;
+    }
+    getTopicFilters(tenantId, namespaceId, dataSourceModifier) {
+        const topicFilters = {
+            tenant: tenantId,
+            namespace: namespaceId,
+            currentPage: dataSourceModifier.pagination.currentPage,
+            pageSize: dataSourceModifier.pagination.pageSize
+        };
+        return dataSourceModifier.columns.reduce((topicFilters, column) => {
+            if (column.filterable) {
+                if (column.filterPredicate) {
+                    topicFilters[column.path] = column.filterPredicate;
+                }
+                if (column.externalFilterQuery) {
+                    topicFilters[column.path] = column.filteringConfig.getFilter(column.externalFilterQuery);
+                }
+            }
+            if (column.sortable && column.sortOrder) {
+                const sortPath = column.sortingConfig?.pathSortingConfigs?.[0]?.path || column.path;
+                topicFilters.sort = `${sortPath},${column.sortOrder}`;
+            }
+            return topicFilters;
+        }, topicFilters);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TopicsDataGridService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TopicsDataGridService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TopicsDataGridService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"topics-data-grid.service.js","sourceRoot":"","sources":["../../../../../messaging-management/messaging/topic/topics-data-grid.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport {\n  BaseColumn,\n  Column,\n  DataSourceModifier,\n  gettext,\n  ServerSideDataResult\n} from '@c8y/ngx-components';\nimport { MessagingTopicListFilters } from '../../api/model/topicListFilters';\nimport { MessagingTopicsService } from '../../api/services/messaging-topics.service';\n\n@Injectable({ providedIn: 'root' })\nexport class TopicsDataGridService {\n  protected topicsService = inject(MessagingTopicsService);\n\n  getColumns(): Column[] {\n    return [\n      this.createColumn({\n        name: 'name',\n        header: gettext('Name'),\n        path: 'name',\n        filterable: true,\n        filteringConfig: {\n          fields: [\n            {\n              key: 'name',\n              type: 'input',\n              props: {\n                label: gettext('Filter topics by partial name'),\n                placeholder: 'myTopic',\n                required: true\n              }\n            }\n          ],\n          getFilter(model: { name: string }): string {\n            return model.name;\n          }\n        }\n      }),\n      this.createColumn({\n        name: 'msgRateIn',\n        header: gettext('Message rate in (msg/s)'),\n        path: 'msgRateIn'\n      }),\n      this.createColumn({\n        name: 'msgRateOut',\n        header: gettext('Message rate out (msg/s)'),\n        path: 'msgRateOut'\n      }),\n      this.createColumn({\n        name: 'subscribers',\n        header: gettext('Subscribers'),\n        path: 'subscribers'\n      }),\n      this.createColumn({\n        name: 'backlogSize',\n        header: gettext('Message backlog'),\n        path: 'backlogSize'\n      }),\n      this.createColumn({\n        name: 'backlogUsagePercentage',\n        header: gettext('Used backlog'),\n        path: 'backlogUsagePercentage',\n        sortOrder: 'desc'\n      })\n    ];\n  }\n\n  async getServerSideData(\n    tenantId: string,\n    namespaceId: string,\n    dataSourceModifier: DataSourceModifier\n  ): Promise<ServerSideDataResult> {\n    const topicFilters = this.getTopicFilters(tenantId, namespaceId, dataSourceModifier);\n    const { res, data, paging } = await this.topicsService.list(topicFilters);\n    const filteredSize = paging.totalElements;\n    const size = (\n      await this.topicsService.list({\n        ...topicFilters,\n        currentPage: 1,\n        pageSize: 1\n      })\n    ).paging.totalPages;\n\n    return {\n      res,\n      data,\n      paging,\n      size,\n      filteredSize\n    };\n  }\n\n  private createColumn(columnProps: Partial<BaseColumn>): BaseColumn {\n    const column = new BaseColumn();\n    Object.assign(column, columnProps);\n    return column;\n  }\n\n  private getTopicFilters(\n    tenantId: string,\n    namespaceId: string,\n    dataSourceModifier: DataSourceModifier\n  ): MessagingTopicListFilters {\n    const topicFilters: MessagingTopicListFilters = {\n      tenant: tenantId,\n      namespace: namespaceId,\n      currentPage: dataSourceModifier.pagination.currentPage,\n      pageSize: dataSourceModifier.pagination.pageSize\n    };\n\n    return dataSourceModifier.columns.reduce((topicFilters, column) => {\n      if (column.filterable) {\n        if (column.filterPredicate) {\n          topicFilters[column.path] = column.filterPredicate;\n        }\n\n        if (column.externalFilterQuery) {\n          topicFilters[column.path] = column.filteringConfig.getFilter(column.externalFilterQuery);\n        }\n      }\n\n      if (column.sortable && column.sortOrder) {\n        const sortPath = column.sortingConfig?.pathSortingConfigs?.[0]?.path || column.path;\n        topicFilters.sort = `${sortPath},${column.sortOrder}`;\n      }\n\n      return topicFilters;\n    }, topicFilters);\n  }\n}\n"]}

package/esm2022/messaging-management/messaging-management.guard.mjs

@@ -0,0 +1,40 @@
+import { inject, Injectable } from '@angular/core';
+import { Permissions } from '@c8y/ngx-components';
+import { ApplicationService, FeatureService, UserService } from '@c8y/client';
+import { MESSAGING_MANAGEMENT_FEATURE_KEY, MESSAGING_MANAGEMENT_MICROSERVICE_NAME } from './constants';
+import * as i0 from "@angular/core";
+export class MessagingManagementGuard {
+    constructor() {
+        this.userService = inject(UserService);
+        this.featureService = inject(FeatureService);
+        this.applicationService = inject(ApplicationService);
+        this.cachedResult = null;
+    }
+    async canActivate() {
+        if (this.cachedResult !== null) {
+            return this.cachedResult;
+        }
+        const currentUser = (await this.userService.current()).data;
+        const hasRequiredRoles = this.userService.hasAnyRole(currentUser, [
+            Permissions.ROLE_TENANT_STATISTICS_READ,
+            Permissions.ROLE_TENANT_MANAGEMENT_ADMIN
+        ]);
+        const featureEnabled = await this.featureService
+            .detail(MESSAGING_MANAGEMENT_FEATURE_KEY)
+            .then(({ data }) => data.active)
+            .catch(() => false);
+        const microserviceSubscribed = await this.applicationService
+            .isAvailable(MESSAGING_MANAGEMENT_MICROSERVICE_NAME)
+            .then(({ data: subscribed }) => subscribed)
+            .catch(() => false);
+        this.cachedResult = hasRequiredRoles && featureEnabled && microserviceSubscribed;
+        return this.cachedResult;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/messaging-management/messaging-management.module.mjs

@@ -0,0 +1,72 @@
+import { NgModule } from '@angular/core';
+import { hookNavigator, hookRoute, hookTab } from '@c8y/ngx-components';
+import { MessagingNavigatorNodeFactory } from './navigator/messaging-navigator-factory';
+import { NamespaceListComponent } from './messaging/namespace-list/namespace-list.component';
+import { TopicListViewComponent } from './messaging/topic/topic-list-view.component';
+import { TopicSubscribersViewComponent } from './messaging/topic/topic-subscribers-view/topic-subscribers-view.component';
+import { TopicDetailsTabFactory } from './navigator/topic-details-tab.factory';
+import { basePath } from './constants';
+import { MessagingManagementGuard } from './messaging-management.guard';
+import * as i0 from "@angular/core";
+export class MessagingManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementModule, providers: [
+            hookRoute([
+                {
+                    path: basePath,
+                    component: NamespaceListComponent,
+                    canActivate: [MessagingManagementGuard]
+                },
+                {
+                    path: basePath + '/namespace/:namespace',
+                    component: TopicListViewComponent,
+                    canActivate: [MessagingManagementGuard]
+                },
+                {
+                    path: basePath + '/namespace/:namespace/topic/:topic',
+                    redirectTo: basePath + '/namespace/:namespace/topic/:topic/subscribers',
+                    pathMatch: 'full'
+                },
+                {
+                    path: basePath + '/namespace/:namespace/topic/:topic/subscribers',
+                    component: TopicSubscribersViewComponent,
+                    canActivate: [MessagingManagementGuard]
+                }
+            ]),
+            hookTab(TopicDetailsTabFactory),
+            hookNavigator(MessagingNavigatorNodeFactory)
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        hookRoute([
+                            {
+                                path: basePath,
+                                component: NamespaceListComponent,
+                                canActivate: [MessagingManagementGuard]
+                            },
+                            {
+                                path: basePath + '/namespace/:namespace',
+                                component: TopicListViewComponent,
+                                canActivate: [MessagingManagementGuard]
+                            },
+                            {
+                                path: basePath + '/namespace/:namespace/topic/:topic',
+                                redirectTo: basePath + '/namespace/:namespace/topic/:topic/subscribers',
+                                pathMatch: 'full'
+                            },
+                            {
+                                path: basePath + '/namespace/:namespace/topic/:topic/subscribers',
+                                component: TopicSubscribersViewComponent,
+                                canActivate: [MessagingManagementGuard]
+                            }
+                        ]),
+                        hookTab(TopicDetailsTabFactory),
+                        hookNavigator(MessagingNavigatorNodeFactory)
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/messaging-management/navigator/messaging-navigator-factory.mjs

@@ -0,0 +1,55 @@
+import { inject, Injectable } from '@angular/core';
+import { AppStateService, gettext, NavigatorNode, NavigatorService } from '@c8y/ngx-components';
+import { NAMESPACE_PROPS } from '../utils/namespace-props';
+import { MessagingNamespacesService } from '../api/services/messaging-namespaces.service';
+import { catchError, filter, map, shareReplay, switchMap, take } from 'rxjs/operators';
+import { from } from 'rxjs';
+import { MessagingManagementGuard } from '../messaging-management.guard';
+import * as i0 from "@angular/core";
+const baseNode = new NavigatorNode({
+    label: gettext('Messaging service'),
+    icon: 'arrows-dotted-left-right',
+    path: 'monitoring/messaging-service',
+    priority: 100,
+    parent: {
+        label: gettext('Monitoring'),
+        icon: 'monitoring'
+    }
+});
+export class MessagingNavigatorNodeFactory {
+    constructor() {
+        this.appState = inject(AppStateService);
+        this.navigatorService = inject(NavigatorService);
+        this.namespacesService = inject(MessagingNamespacesService);
+        this.guard = inject(MessagingManagementGuard);
+        this.currentTenantId = this.appState.currentTenant.pipe(filter(currentTenant => !!currentTenant), map(currentTenant => currentTenant.name), take(1));
+        this.navigatorNode$ = from(this.guard.canActivate()).pipe(filter(allowed => allowed), switchMap(() => this.currentTenantId), switchMap(currentTenantId => this.namespacesService.getNamespaces(currentTenantId)), map(({ namespaces }) => {
+            if (!namespaces?.length) {
+                return [];
+            }
+            namespaces.forEach(namespace => {
+                const label = NAMESPACE_PROPS[namespace.name]?.label || namespace.name;
+                const childNode = new NavigatorNode({
+                    label,
+                    path: `monitoring/messaging-service/namespace/${namespace.name}`,
+                    icon: NAMESPACE_PROPS[namespace.name]?.icon,
+                    routerLinkExact: false
+                });
+                baseNode.add(childNode);
+            });
+            return baseNode;
+        }), catchError(() => {
+            return [];
+        }), shareReplay(1));
+    }
+    get() {
+        return this.navigatorNode$;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingNavigatorNodeFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingNavigatorNodeFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessagingNavigatorNodeFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnaW5nLW5hdmlnYXRvci1mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbWVzc2FnaW5nLW1hbmFnZW1lbnQvbmF2aWdhdG9yL21lc3NhZ2luZy1uYXZpZ2F0b3ItZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQ0wsZUFBZSxFQUVmLE9BQU8sRUFDUCxhQUFhLEVBQ2IsZ0JBQWdCLEVBQ2pCLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzNELE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQzFGLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxJQUFJLEVBQWMsTUFBTSxNQUFNLENBQUM7QUFDeEMsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sK0JBQStCLENBQUM7O0FBRXpFLE1BQU0sUUFBUSxHQUFHLElBQUksYUFBYSxDQUFDO0lBQ2pDLEtBQUssRUFBRSxPQUFPLENBQUMsbUJBQW1CLENBQUM7SUFDbkMsSUFBSSxFQUFFLDBCQUEwQjtJQUNoQyxJQUFJLEVBQUUsOEJBQThCO0lBQ3BDLFFBQVEsRUFBRSxHQUFHO0lBQ2IsTUFBTSxFQUFFO1FBQ04sS0FBSyxFQUFFLE9BQU8sQ0FBQyxZQUFZLENBQUM7UUFDNUIsSUFBSSxFQUFFLFlBQVk7S0FDbkI7Q0FDRixDQUFDLENBQUM7QUFHSCxNQUFNLE9BQU8sNkJBQTZCO0lBY3hDO1FBYkEsYUFBUSxHQUFHLE1BQU0sQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUNuQyxxQkFBZ0IsR0FBRyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUM1QyxzQkFBaUIsR0FBRyxNQUFNLENBQUMsMEJBQTBCLENBQUMsQ0FBQztRQUN2RCxVQUFLLEdBQUcsTUFBTSxDQUFDLHdCQUF3QixDQUFDLENBQUM7UUFFekMsb0JBQWUsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQ2hELE1BQU0sQ0FBQyxhQUFhLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsRUFDeEMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxFQUN4QyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQ1IsQ0FBQztRQUtBLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQ3ZELE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxFQUMxQixTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxFQUNyQyxTQUFTLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsYUFBYSxDQUFDLGVBQWUsQ0FBQyxDQUFDLEVBQ25GLEdBQUcsQ0FBQyxDQUFDLEVBQUUsVUFBVSxFQUFFLEVBQUUsRUFBRTtZQUNyQixJQUFJLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxDQUFDO2dCQUN4QixPQUFPLEVBQUUsQ0FBQztZQUNaLENBQUM7WUFDRCxVQUFVLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFO2dCQUM3QixNQUFNLEtBQUssR0FBRyxlQUFlLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLEtBQUssSUFBSSxTQUFTLENBQUMsSUFBSSxDQUFDO2dCQUN2RSxNQUFNLFNBQVMsR0FBRyxJQUFJLGFBQWEsQ0FBQztvQkFDbEMsS0FBSztvQkFDTCxJQUFJLEVBQUUsMENBQTBDLFNBQVMsQ0FBQyxJQUFJLEVBQUU7b0JBQ2hFLElBQUksRUFBRSxlQUFlLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLElBQUk7b0JBQzNDLGVBQWUsRUFBRSxLQUFLO2lCQUN2QixDQUFDLENBQUM7Z0JBQ0gsUUFBUSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUMxQixDQUFDLENBQUMsQ0FBQztZQUNILE9BQU8sUUFBUSxDQUFDO1FBQ2xCLENBQUMsQ0FBQyxFQUNGLFVBQVUsQ0FBQyxHQUFHLEVBQUU7WUFDZCxPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUMsQ0FBQyxFQUNGLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FDZixDQUFDO0lBQ0osQ0FBQztJQUVELEdBQUc7UUFDRCxPQUFPLElBQUksQ0FBQyxjQUFjLENBQUM7SUFDN0IsQ0FBQzsrR0E1Q1UsNkJBQTZCO21IQUE3Qiw2QkFBNkIsY0FEaEIsTUFBTTs7NEZBQ25CLDZCQUE2QjtrQkFEekMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIEFwcFN0YXRlU2VydmljZSxcbiAgRXh0ZW5zaW9uRmFjdG9yeSxcbiAgZ2V0dGV4dCxcbiAgTmF2aWdhdG9yTm9kZSxcbiAgTmF2aWdhdG9yU2VydmljZVxufSBmcm9tICdAYzh5L25neC1jb21wb25lbnRzJztcbmltcG9ydCB7IE5BTUVTUEFDRV9QUk9QUyB9IGZyb20gJy4uL3V0aWxzL25hbWVzcGFjZS1wcm9wcyc7XG5pbXBvcnQgeyBNZXNzYWdpbmdOYW1lc3BhY2VzU2VydmljZSB9IGZyb20gJy4uL2FwaS9zZXJ2aWNlcy9tZXNzYWdpbmctbmFtZXNwYWNlcy5zZXJ2aWNlJztcbmltcG9ydCB7IGNhdGNoRXJyb3IsIGZpbHRlciwgbWFwLCBzaGFyZVJlcGxheSwgc3dpdGNoTWFwLCB0YWtlIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgZnJvbSwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgTWVzc2FnaW5nTWFuYWdlbWVudEd1YXJkIH0gZnJvbSAnLi4vbWVzc2FnaW5nLW1hbmFnZW1lbnQuZ3VhcmQnO1xuXG5jb25zdCBiYXNlTm9kZSA9IG5ldyBOYXZpZ2F0b3JOb2RlKHtcbiAgbGFiZWw6IGdldHRleHQoJ01lc3NhZ2luZyBzZXJ2aWNlJyksXG4gIGljb246ICdhcnJvd3MtZG90dGVkLWxlZnQtcmlnaHQnLFxuICBwYXRoOiAnbW9uaXRvcmluZy9tZXNzYWdpbmctc2VydmljZScsXG4gIHByaW9yaXR5OiAxMDAsXG4gIHBhcmVudDoge1xuICAgIGxhYmVsOiBnZXR0ZXh0KCdNb25pdG9yaW5nJyksXG4gICAgaWNvbjogJ21vbml0b3JpbmcnXG4gIH1cbn0pO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIE1lc3NhZ2luZ05hdmlnYXRvck5vZGVGYWN0b3J5IGltcGxlbWVudHMgRXh0ZW5zaW9uRmFjdG9yeTxOYXZpZ2F0b3JOb2RlPiB7XG4gIGFwcFN0YXRlID0gaW5qZWN0KEFwcFN0YXRlU2VydmljZSk7XG4gIG5hdmlnYXRvclNlcnZpY2UgPSBpbmplY3QoTmF2aWdhdG9yU2VydmljZSk7XG4gIG5hbWVzcGFjZXNTZXJ2aWNlID0gaW5qZWN0KE1lc3NhZ2luZ05hbWVzcGFjZXNTZXJ2aWNlKTtcbiAgZ3VhcmQgPSBpbmplY3QoTWVzc2FnaW5nTWFuYWdlbWVudEd1YXJkKTtcblxuICBjdXJyZW50VGVuYW50SWQgPSB0aGlzLmFwcFN0YXRlLmN1cnJlbnRUZW5hbnQucGlwZShcbiAgICBmaWx0ZXIoY3VycmVudFRlbmFudCA9PiAhIWN1cnJlbnRUZW5hbnQpLFxuICAgIG1hcChjdXJyZW50VGVuYW50ID0+IGN1cnJlbnRUZW5hbnQubmFtZSksXG4gICAgdGFrZSgxKVxuICApO1xuXG4gIG5hdmlnYXRvck5vZGUkOiBPYnNlcnZhYmxlPE5hdmlnYXRvck5vZGUgfCBOYXZpZ2F0b3JOb2RlW10+O1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMubmF2aWdhdG9yTm9kZSQgPSBmcm9tKHRoaXMuZ3VhcmQuY2FuQWN0aXZhdGUoKSkucGlwZShcbiAgICAgIGZpbHRlcihhbGxvd2VkID0+IGFsbG93ZWQpLFxuICAgICAgc3dpdGNoTWFwKCgpID0+IHRoaXMuY3VycmVudFRlbmFudElkKSxcbiAgICAgIHN3aXRjaE1hcChjdXJyZW50VGVuYW50SWQgPT4gdGhpcy5uYW1lc3BhY2VzU2VydmljZS5nZXROYW1lc3BhY2VzKGN1cnJlbnRUZW5hbnRJZCkpLFxuICAgICAgbWFwKCh7IG5hbWVzcGFjZXMgfSkgPT4ge1xuICAgICAgICBpZiAoIW5hbWVzcGFjZXM/Lmxlbmd0aCkge1xuICAgICAgICAgIHJldHVybiBbXTtcbiAgICAgICAgfVxuICAgICAgICBuYW1lc3BhY2VzLmZvckVhY2gobmFtZXNwYWNlID0+IHtcbiAgICAgICAgICBjb25zdCBsYWJlbCA9IE5BTUVTUEFDRV9QUk9QU1tuYW1lc3BhY2UubmFtZV0/LmxhYmVsIHx8IG5hbWVzcGFjZS5uYW1lO1xuICAgICAgICAgIGNvbnN0IGNoaWxkTm9kZSA9IG5ldyBOYXZpZ2F0b3JOb2RlKHtcbiAgICAgICAgICAgIGxhYmVsLFxuICAgICAgICAgICAgcGF0aDogYG1vbml0b3JpbmcvbWVzc2FnaW5nLXNlcnZpY2UvbmFtZXNwYWNlLyR7bmFtZXNwYWNlLm5hbWV9YCxcbiAgICAgICAgICAgIGljb246IE5BTUVTUEFDRV9QUk9QU1tuYW1lc3BhY2UubmFtZV0/Lmljb24sXG4gICAgICAgICAgICByb3V0ZXJMaW5rRXhhY3Q6IGZhbHNlXG4gICAgICAgICAgfSk7XG4gICAgICAgICAgYmFzZU5vZGUuYWRkKGNoaWxkTm9kZSk7XG4gICAgICAgIH0pO1xuICAgICAgICByZXR1cm4gYmFzZU5vZGU7XG4gICAgICB9KSxcbiAgICAgIGNhdGNoRXJyb3IoKCkgPT4ge1xuICAgICAgICByZXR1cm4gW107XG4gICAgICB9KSxcbiAgICAgIHNoYXJlUmVwbGF5KDEpXG4gICAgKTtcbiAgfVxuXG4gIGdldCgpOiBPYnNlcnZhYmxlPE5hdmlnYXRvck5vZGUgfCBOYXZpZ2F0b3JOb2RlW10+IHtcbiAgICByZXR1cm4gdGhpcy5uYXZpZ2F0b3JOb2RlJDtcbiAgfVxufVxuIl19

package/esm2022/messaging-management/navigator/topic-details-tab.factory.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { gettext } from '@c8y/ngx-components';
+import { Router } from '@angular/router';
+import { basePath } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class TopicDetailsTabFactory {
+    constructor(router) {
+        this.router = router;
+    }
+    get() {
+        const pattern = /\/namespace\/(.+)\/topic\/(.+)\/subscribers$/;
+        const matches = this.router.url.match(pattern);
+        if (matches) {
+            const namespace = matches[1];
+            const topic = matches[2];
+            return [
+                {
+                    path: basePath + `/namespace/${namespace}/topic/${topic}/subscribers`,
+                    priority: 500,
+                    label: gettext('Subscribers')
+                }
+            ];
+        }
+        return [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TopicDetailsTabFactory, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TopicDetailsTabFactory }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TopicDetailsTabFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Router }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/messaging-management/utils/backlog-quota-limit.pipe.mjs

@@ -0,0 +1,32 @@
+import { formatNumber } from '@angular/common';
+import { inject, LOCALE_ID, Pipe } from '@angular/core';
+import { gettext } from '@c8y/ngx-components';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+/**
+ * In case of limits in Messaging management, value of '-1' means that there is no limit.
+ */
+export class BacklogQuotaLimitPipe {
+    constructor() {
+        this.translateService = inject(TranslateService);
+        this.locale = inject(LOCALE_ID);
+    }
+    transform(value) {
+        if (value == null || isNaN(value)) {
+            return '-';
+        }
+        else if (value === -1) {
+            return this.translateService.instant(gettext('Unlimited` backlog quota`'));
+        }
+        else {
+            return formatNumber(value, this.locale);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BacklogQuotaLimitPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: BacklogQuotaLimitPipe, isStandalone: true, name: "backlogQuotaLimit" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BacklogQuotaLimitPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'backlogQuotaLimit', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/messaging-management/utils/namespace-props.mjs

@@ -0,0 +1,23 @@
+import { gettext } from '@c8y/ngx-components';
+/**
+ * Currently known namespaces and their properties.
+ */
+export const NAMESPACE_PROPS = {
+    mqtt: {
+        icon: 'c8y-device-protocols',
+        label: gettext('MQTT Service')
+    },
+    'data-broker-fwd': {
+        icon: 'c8y-data-broker',
+        label: gettext('Data Broker')
+    },
+    relnotif: {
+        icon: 'c8y-notification',
+        label: gettext('Notifications 2.0')
+    },
+    'streaming-analytics': {
+        icon: 'c8y-streaming-analytics',
+        label: gettext('Streaming Analytics')
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFtZXNwYWNlLXByb3BzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbWVzc2FnaW5nLW1hbmFnZW1lbnQvdXRpbHMvbmFtZXNwYWNlLXByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQU85Qzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBbUM7SUFDN0QsSUFBSSxFQUFFO1FBQ0osSUFBSSxFQUFFLHNCQUFzQjtRQUM1QixLQUFLLEVBQUUsT0FBTyxDQUFDLGNBQWMsQ0FBQztLQUMvQjtJQUNELGlCQUFpQixFQUFFO1FBQ2pCLElBQUksRUFBRSxpQkFBaUI7UUFDdkIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxhQUFhLENBQUM7S0FDOUI7SUFDRCxRQUFRLEVBQUU7UUFDUixJQUFJLEVBQUUsa0JBQWtCO1FBQ3hCLEtBQUssRUFBRSxPQUFPLENBQUMsbUJBQW1CLENBQUM7S0FDcEM7SUFDRCxxQkFBcUIsRUFBRTtRQUNyQixJQUFJLEVBQUUseUJBQXlCO1FBQy9CLEtBQUssRUFBRSxPQUFPLENBQUMscUJBQXFCLENBQUM7S0FDdEM7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0dGV4dCB9IGZyb20gJ0BjOHkvbmd4LWNvbXBvbmVudHMnO1xuXG50eXBlIE5hbWVzcGFjZVByb3BzID0ge1xuICBpY29uOiBzdHJpbmc7XG4gIGxhYmVsOiBzdHJpbmc7XG59O1xuXG4vKipcbiAqIEN1cnJlbnRseSBrbm93biBuYW1lc3BhY2VzIGFuZCB0aGVpciBwcm9wZXJ0aWVzLlxuICovXG5leHBvcnQgY29uc3QgTkFNRVNQQUNFX1BST1BTOiBSZWNvcmQ8c3RyaW5nLCBOYW1lc3BhY2VQcm9wcz4gPSB7XG4gIG1xdHQ6IHtcbiAgICBpY29uOiAnYzh5LWRldmljZS1wcm90b2NvbHMnLFxuICAgIGxhYmVsOiBnZXR0ZXh0KCdNUVRUIFNlcnZpY2UnKVxuICB9LFxuICAnZGF0YS1icm9rZXItZndkJzoge1xuICAgIGljb246ICdjOHktZGF0YS1icm9rZXInLFxuICAgIGxhYmVsOiBnZXR0ZXh0KCdEYXRhIEJyb2tlcicpXG4gIH0sXG4gIHJlbG5vdGlmOiB7XG4gICAgaWNvbjogJ2M4eS1ub3RpZmljYXRpb24nLFxuICAgIGxhYmVsOiBnZXR0ZXh0KCdOb3RpZmljYXRpb25zIDIuMCcpXG4gIH0sXG4gICdzdHJlYW1pbmctYW5hbHl0aWNzJzoge1xuICAgIGljb246ICdjOHktc3RyZWFtaW5nLWFuYWx5dGljcycsXG4gICAgbGFiZWw6IGdldHRleHQoJ1N0cmVhbWluZyBBbmFseXRpY3MnKVxuICB9XG59O1xuIl19

package/esm2022/messaging-management/utils/time-to-live.pipe.mjs

@@ -0,0 +1,122 @@
+import { Pipe } from '@angular/core';
+import { gettext } from '@c8y/ngx-components';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class TimeToLivePipe {
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    /**
+     * Transform time in seconds to human readable format.
+     * @param seconds time in seconds
+     * @returns human readable time period
+     */
+    transform(seconds) {
+        if (seconds == null || isNaN(seconds)) {
+            return '-';
+        }
+        if (seconds === -1) {
+            return this.translateService.instant(gettext('Unlimited` time-to-live period`'));
+        }
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days >= 1) {
+            const remainingHours = hours % 24;
+            if (days === 1) {
+                if (remainingHours === 0) {
+                    return this.translateService.instant(gettext('1 day'));
+                }
+                if (remainingHours === 1) {
+                    return this.translateService.instant(gettext('1 day 1 hour'));
+                }
+                return this.translateService.instant(gettext('1 day {{hours}} hours'), {
+                    hours: remainingHours
+                });
+            }
+            else {
+                if (remainingHours === 0) {
+                    return this.translateService.instant(gettext('{{days}} days'), { days });
+                }
+                if (remainingHours === 1) {
+                    return this.translateService.instant(gettext('{{days}} days 1 hour'), { days });
+                }
+                return this.translateService.instant(gettext('{{days}} days {{hours}} hours'), {
+                    days,
+                    hours: remainingHours
+                });
+            }
+        }
+        if (hours > 0) {
+            const remainingMinutes = minutes % 60;
+            if (hours === 1) {
+                if (remainingMinutes === 0) {
+                    return this.translateService.instant(gettext('1 hour'));
+                }
+                if (remainingMinutes === 1) {
+                    return this.translateService.instant(gettext('1 hour 1 minute'));
+                }
+                return this.translateService.instant(gettext('1 hour {{minutes}} minutes'), {
+                    minutes: remainingMinutes
+                });
+            }
+            else {
+                if (remainingMinutes === 0) {
+                    return this.translateService.instant(gettext('{{hours}} hours'), { hours });
+                }
+                if (remainingMinutes === 1) {
+                    return this.translateService.instant(gettext('{{hours}} hours 1 minute'), { hours });
+                }
+                return this.translateService.instant(gettext('{{hours}} hours {{minutes}} minutes'), {
+                    hours,
+                    minutes: remainingMinutes
+                });
+            }
+        }
+        if (minutes > 0) {
+            const remainingSeconds = seconds % 60;
+            if (minutes === 1) {
+                if (remainingSeconds === 0) {
+                    return this.translateService.instant(gettext('1 minute'));
+                }
+                if (remainingSeconds === 1) {
+                    return this.translateService.instant(gettext('1 minute 1 second'));
+                }
+                return this.translateService.instant(gettext('1 minute {{seconds}} seconds'), {
+                    seconds: remainingSeconds
+                });
+            }
+            else {
+                if (remainingSeconds === 0) {
+                    return this.translateService.instant(gettext('{{minutes}} minutes'), { minutes });
+                }
+                if (remainingSeconds === 1) {
+                    return this.translateService.instant(gettext('{{minutes}} minutes 1 second'), {
+                        minutes
+                    });
+                }
+                return this.translateService.instant(gettext('{{minutes}} minutes {{seconds}} seconds'), {
+                    minutes,
+                    seconds: remainingSeconds
+                });
+            }
+        }
+        if (seconds === 1) {
+            return this.translateService.instant(gettext('1 second'));
+        }
+        else {
+            return this.translateService.instant(gettext('{{seconds}} seconds'), { seconds });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimeToLivePipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TimeToLivePipe, isStandalone: true, name: "timeToLive" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimeToLivePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'timeToLive',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-to-live.pipe.js","sourceRoot":"","sources":["../../../../messaging-management/utils/time-to-live.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\nimport { gettext } from '@c8y/ngx-components';\nimport { TranslateService } from '@ngx-translate/core';\n\n@Pipe({\n  name: 'timeToLive',\n  standalone: true\n})\nexport class TimeToLivePipe implements PipeTransform {\n  constructor(private translateService: TranslateService) {}\n\n  /**\n   * Transform time in seconds to human readable format.\n   * @param seconds time in seconds\n   * @returns human readable time period\n   */\n  transform(seconds: number | null): string {\n    if (seconds == null || isNaN(seconds)) {\n      return '-';\n    }\n    if (seconds === -1) {\n      return this.translateService.instant(gettext('Unlimited` time-to-live period`'));\n    }\n    const minutes = Math.floor(seconds / 60);\n    const hours = Math.floor(minutes / 60);\n    const days = Math.floor(hours / 24);\n\n    if (days >= 1) {\n      const remainingHours = hours % 24;\n      if (days === 1) {\n        if (remainingHours === 0) {\n          return this.translateService.instant(gettext('1 day'));\n        }\n        if (remainingHours === 1) {\n          return this.translateService.instant(gettext('1 day 1 hour'));\n        }\n        return this.translateService.instant(gettext('1 day {{hours}} hours'), {\n          hours: remainingHours\n        });\n      } else {\n        if (remainingHours === 0) {\n          return this.translateService.instant(gettext('{{days}} days'), { days });\n        }\n        if (remainingHours === 1) {\n          return this.translateService.instant(gettext('{{days}} days 1 hour'), { days });\n        }\n        return this.translateService.instant(gettext('{{days}} days {{hours}} hours'), {\n          days,\n          hours: remainingHours\n        });\n      }\n    }\n\n    if (hours > 0) {\n      const remainingMinutes = minutes % 60;\n      if (hours === 1) {\n        if (remainingMinutes === 0) {\n          return this.translateService.instant(gettext('1 hour'));\n        }\n        if (remainingMinutes === 1) {\n          return this.translateService.instant(gettext('1 hour 1 minute'));\n        }\n        return this.translateService.instant(gettext('1 hour {{minutes}} minutes'), {\n          minutes: remainingMinutes\n        });\n      } else {\n        if (remainingMinutes === 0) {\n          return this.translateService.instant(gettext('{{hours}} hours'), { hours });\n        }\n        if (remainingMinutes === 1) {\n          return this.translateService.instant(gettext('{{hours}} hours 1 minute'), { hours });\n        }\n        return this.translateService.instant(gettext('{{hours}} hours {{minutes}} minutes'), {\n          hours,\n          minutes: remainingMinutes\n        });\n      }\n    }\n\n    if (minutes > 0) {\n      const remainingSeconds = seconds % 60;\n      if (minutes === 1) {\n        if (remainingSeconds === 0) {\n          return this.translateService.instant(gettext('1 minute'));\n        }\n        if (remainingSeconds === 1) {\n          return this.translateService.instant(gettext('1 minute 1 second'));\n        }\n        return this.translateService.instant(gettext('1 minute {{seconds}} seconds'), {\n          seconds: remainingSeconds\n        });\n      } else {\n        if (remainingSeconds === 0) {\n          return this.translateService.instant(gettext('{{minutes}} minutes'), { minutes });\n        }\n        if (remainingSeconds === 1) {\n          return this.translateService.instant(gettext('{{minutes}} minutes 1 second'), {\n            minutes\n          });\n        }\n        return this.translateService.instant(gettext('{{minutes}} minutes {{seconds}} seconds'), {\n          minutes,\n          seconds: remainingSeconds\n        });\n      }\n    }\n\n    if (seconds === 1) {\n      return this.translateService.instant(gettext('1 second'));\n    } else {\n      return this.translateService.instant(gettext('{{seconds}} seconds'), { seconds });\n    }\n  }\n}\n"]}

package/esm2022/operations/device-selector/device-selector.component.mjs

@@ -33,6 +33,10 @@ export class DeviceSelectorComponent {
             this.deviceTypes
                 .pipe(distinctUntilChanged(), takeUntil(this.unsubscribe$))
                 .subscribe((types) => {
+                // there is a concurrency issue when updateFiltering is called before the columns have actually been passed into the grid
+                // so we are already updating the typeColumn here additionally so in case updateFiltering has no affect, the type column is still correctly filtered
+                // "Dynamic group created for bulk operation should be invisible" cypress tests of configurationUpdateBulkOperation.cy.ts started failing otherwise
+                this.typeColumn.externalFilterQuery = { types };
                 this.deviceGrid.updateFiltering([this.typeColumn.name], {
                     type: types && types.length
                         ? FilteringActionType.ApplyFilter
@@ -86,4 +90,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], onDeviceQueryStringChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV2aWNlLXNlbGVjdG9yLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL29wZXJhdGlvbnMvZGV2aWNlLXNlbGVjdG9yL2RldmljZS1zZWxlY3Rvci5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi9vcGVyYXRpb25zL2RldmljZS1zZWxlY3Rvci9kZXZpY2Utc2VsZWN0b3IuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFNBQVMsRUFDVCxZQUFZLEVBQ1osS0FBSyxFQUdMLE1BQU0sRUFDTixTQUFTLEVBQ1YsTUFBTSxlQUFlLENBQUM7QUFDdkIsT0FBTyxFQUVMLCtCQUErQixFQUMvQixnQ0FBZ0MsRUFDaEMsbUJBQW1CLEVBQ25CLG9DQUFvQyxFQUVyQyxNQUFNLHFCQUFxQixDQUFDO0FBQzdCLE9BQU8sRUFDTCxzQkFBc0IsRUFDdEIsbUJBQW1CLEVBQ25CLHFCQUFxQixFQUNyQixxQkFBcUIsRUFDckIsb0JBQW9CLEVBQ3BCLGdDQUFnQyxFQUNoQyxzQkFBc0IsRUFDdEIsb0JBQW9CLEVBQ3JCLE1BQU0saUNBQWlDLENBQUM7QUFDekMsT0FBTyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDM0MsT0FBTyxFQUFFLG9CQUFvQixFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDOzs7O0FBRWpFLE1BQU0sZUFBZSxHQUFHLGtCQUFrQixDQUFDO0FBZTNDLE1BQU0sT0FBTyx1QkFBdUI7SUFkcEM7UUE0QkUsZUFBVSxHQUFXLElBQUksb0JBQW9CLEVBQUUsQ0FBQztRQUdoRCw4QkFBeUIsR0FBeUIsSUFBSSxZQUFZLEVBQVUsQ0FBQztRQUU3RSxZQUFPLEdBQWE7WUFDbEIsSUFBSSxzQkFBc0IsRUFBRTtZQUM1QixJQUFJLG9CQUFvQixFQUFFO1lBQzFCLElBQUksQ0FBQyxVQUFVO1lBQ2YsSUFBSSxxQkFBcUIsRUFBRTtZQUMzQixJQUFJLHFCQUFxQixFQUFFO1lBQzNCLElBQUksZ0NBQWdDLEVBQUU7WUFDdEMsSUFBSSxzQkFBc0IsRUFBRTtTQUM3QixDQUFDO1FBRU0saUJBQVksR0FBcUIsSUFBSSxPQUFPLEVBQUUsQ0FBQztLQThCeEQ7YUExRGlCLHdCQUFtQixHQUFxQztRQUN0RSxHQUFHLEVBQUUsZUFBZTtRQUNwQixZQUFZLEVBQUU7WUFDWixNQUFNLEVBQUUsS0FBSztTQUNkO0tBQ0YsQUFMa0MsQ0FLakM7SUF5QkYsUUFBUTtRQUNOLElBQUksSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3JCLElBQUksQ0FBQyxXQUFXO2lCQUNiLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7aUJBQzFELFNBQVMsQ0FBQyxDQUFDLEtBQWUsRUFBRSxFQUFFO2dCQUM3QixJQUFJLENBQUMsVUFBVSxDQUFDLGVBQWUsQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUU7b0JBQ3RELElBQUksRUFDRixLQUFLLElBQUksS0FBSyxDQUFDLE1BQU07d0JBQ25CLENBQUMsQ0FBQyxtQkFBbUIsQ0FBQyxXQUFXO3dCQUNqQyxDQUFDLENBQUMsbUJBQW1CLENBQUMsV0FBVztvQkFDckMsT0FBTyxFQUFFLEtBQUs7d0JBQ1osQ0FBQyxDQUFDOzRCQUNFLGlCQUFpQixFQUFFO2dDQUNqQixtQkFBbUIsRUFBRTtvQ0FDbkIsS0FBSztpQ0FDTjs2QkFDRjt5QkFDRjt3QkFDSCxDQUFDLENBQUMsU0FBUztpQkFDZCxDQUFDLENBQUM7WUFDTCxDQUFDLENBQUMsQ0FBQztRQUNQLENBQUM7SUFDSCxDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzdCLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDL0IsQ0FBQzsrR0ExRFUsdUJBQXVCO21HQUF2Qix1QkFBdUIsMkpBWHZCO1lBQ1Q7Z0JBQ0UsT0FBTyxFQUFFLGdDQUFnQztnQkFDekMsUUFBUSxFQUFFLG9DQUFvQzthQUMvQztZQUNEO2dCQUNFLE9BQU8sRUFBRSwrQkFBK0I7Z0JBQ3hDLFFBQVEsRUFBRSx1QkFBdUIsQ0FBQyxtQkFBbUI7YUFDdEQ7U0FDRixzRUFVVSxtQkFBbUIsOERDckRoQyw4U0FTQTs7NEZEb0NhLHVCQUF1QjtrQkFkbkMsU0FBUzsrQkFDRSxxQkFBcUIsYUFFcEI7d0JBQ1Q7NEJBQ0UsT0FBTyxFQUFFLGdDQUFnQzs0QkFDekMsUUFBUSxFQUFFLG9DQUFvQzt5QkFDL0M7d0JBQ0Q7NEJBQ0UsT0FBTyxFQUFFLCtCQUErQjs0QkFDeEMsUUFBUSxFQUFFLHdCQUF3QixtQkFBbUI7eUJBQ3REO3FCQUNGOzhCQVdELFVBQVU7c0JBRFQsU0FBUzt1QkFBQyxtQkFBbUIsRUFBRSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUU7Z0JBSWhELFdBQVc7c0JBRFYsS0FBSztnQkFNTix5QkFBeUI7c0JBRHhCLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBDb21wb25lbnQsXG4gIEV2ZW50RW1pdHRlcixcbiAgSW5wdXQsXG4gIE9uRGVzdHJveSxcbiAgT25Jbml0LFxuICBPdXRwdXQsXG4gIFZpZXdDaGlsZFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIENvbHVtbixcbiAgREFUQV9HUklEX0NPTkZJR1VSQVRJT05fQ09OVEVYVCxcbiAgREFUQV9HUklEX0NPTkZJR1VSQVRJT05fU1RSQVRFR1ksXG4gIEZpbHRlcmluZ0FjdGlvblR5cGUsXG4gIFVzZXJQcmVmZXJlbmNlc0NvbmZpZ3VyYXRpb25TdHJhdGVneSxcbiAgVXNlclByZWZlcmVuY2VzR3JpZENvbmZpZ0NvbnRleHRcbn0gZnJvbSAnQGM4eS9uZ3gtY29tcG9uZW50cyc7XG5pbXBvcnQge1xuICBBbGFybXNEZXZpY2VHcmlkQ29sdW1uLFxuICBEZXZpY2VHcmlkQ29tcG9uZW50LFxuICBHcm91cERldmljZUdyaWRDb2x1bW4sXG4gIE1vZGVsRGV2aWNlR3JpZENvbHVtbixcbiAgTmFtZURldmljZUdyaWRDb2x1bW4sXG4gIFJlZ2lzdHJhdGlvbkRhdGVEZXZpY2VHcmlkQ29sdW1uLFxuICBTdGF0dXNEZXZpY2VHcmlkQ29sdW1uLFxuICBUeXBlRGV2aWNlR3JpZENvbHVtblxufSBmcm9tICdAYzh5L25neC1jb21wb25lbnRzL2RldmljZS1ncmlkJztcbmltcG9ydCB7IE9ic2VydmFibGUsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IGRpc3RpbmN0VW50aWxDaGFuZ2VkLCB0YWtlVW50aWwgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmNvbnN0IEdSSURfQ09ORklHX0tFWSA9ICdkZXZpY2UtZ3JpZC1idWxrJztcbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2M4eS1kZXZpY2Utc2VsZWN0b3InLFxuICB0ZW1wbGF0ZVVybDogJ2RldmljZS1zZWxlY3Rvci5jb21wb25lbnQuaHRtbCcsXG4gIHByb3ZpZGVyczogW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IERBVEFfR1JJRF9DT05GSUdVUkFUSU9OX1NUUkFURUdZLFxuICAgICAgdXNlQ2xhc3M6IFVzZXJQcmVmZXJlbmNlc0NvbmZpZ3VyYXRpb25TdHJhdGVneVxuICAgIH0sXG4gICAge1xuICAgICAgcHJvdmlkZTogREFUQV9HUklEX0NPTkZJR1VSQVRJT05fQ09OVEVYVCxcbiAgICAgIHVzZVZhbHVlOiBEZXZpY2VTZWxlY3RvckNvbXBvbmVudC5HUklEX0NPTkZJR19DT05URVhUXG4gICAgfVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIERldmljZVNlbGVjdG9yQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBPbkRlc3Ryb3kge1xuICBzdGF0aWMgcmVhZG9ubHkgR1JJRF9DT05GSUdfQ09OVEVYVDogVXNlclByZWZlcmVuY2VzR3JpZENvbmZpZ0NvbnRleHQgPSB7XG4gICAga2V5OiBHUklEX0NPTkZJR19LRVksXG4gICAgY29uZmlnRmlsdGVyOiB7XG4gICAgICBmaWx0ZXI6IGZhbHNlXG4gICAgfVxuICB9O1xuXG4gIEBWaWV3Q2hpbGQoRGV2aWNlR3JpZENvbXBvbmVudCwgeyBzdGF0aWM6IHRydWUgfSlcbiAgZGV2aWNlR3JpZDogRGV2aWNlR3JpZENvbXBvbmVudDtcblxuICBASW5wdXQoKVxuICBkZXZpY2VUeXBlczogT2JzZXJ2YWJsZTxzdHJpbmdbXT47XG5cbiAgdHlwZUNvbHVtbjogQ29sdW1uID0gbmV3IFR5cGVEZXZpY2VHcmlkQ29sdW1uKCk7XG5cbiAgQE91dHB1dCgpXG4gIG9uRGV2aWNlUXVlcnlTdHJpbmdDaGFuZ2U6IEV2ZW50RW1pdHRlcjxzdHJpbmc+ID0gbmV3IEV2ZW50RW1pdHRlcjxzdHJpbmc+KCk7XG5cbiAgY29sdW1uczogQ29sdW1uW10gPSBbXG4gICAgbmV3IFN0YXR1c0RldmljZUdyaWRDb2x1bW4oKSxcbiAgICBuZXcgTmFtZURldmljZUdyaWRDb2x1bW4oKSxcbiAgICB0aGlzLnR5cGVDb2x1bW4sXG4gICAgbmV3IE1vZGVsRGV2aWNlR3JpZENvbHVtbigpLFxuICAgIG5ldyBHcm91cERldmljZUdyaWRDb2x1bW4oKSxcbiAgICBuZXcgUmVnaXN0cmF0aW9uRGF0ZURldmljZUdyaWRDb2x1bW4oKSxcbiAgICBuZXcgQWxhcm1zRGV2aWNlR3JpZENvbHVtbigpXG4gIF07XG5cbiAgcHJpdmF0ZSB1bnN1YnNjcmliZSQ6IFN1YmplY3Q8Ym9vbGVhbj4gPSBuZXcgU3ViamVjdCgpO1xuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIGlmICh0aGlzLmRldmljZVR5cGVzKSB7XG4gICAgICB0aGlzLmRldmljZVR5cGVzXG4gICAgICAgIC5waXBlKGRpc3RpbmN0VW50aWxDaGFuZ2VkKCksIHRha2VVbnRpbCh0aGlzLnVuc3Vic2NyaWJlJCkpXG4gICAgICAgIC5zdWJzY3JpYmUoKHR5cGVzOiBzdHJpbmdbXSkgPT4ge1xuICAgICAgICAgIHRoaXMuZGV2aWNlR3JpZC51cGRhdGVGaWx0ZXJpbmcoW3RoaXMudHlwZUNvbHVtbi5uYW1lXSwge1xuICAgICAgICAgICAgdHlwZTpcbiAgICAgICAgICAgICAgdHlwZXMgJiYgdHlwZXMubGVuZ3RoXG4gICAgICAgICAgICAgICAgPyBGaWx0ZXJpbmdBY3Rpb25UeXBlLkFwcGx5RmlsdGVyXG4gICAgICAgICAgICAgICAgOiBGaWx0ZXJpbmdBY3Rpb25UeXBlLlJlc2V0RmlsdGVyLFxuICAgICAgICAgICAgcGF5bG9hZDogdHlwZXNcbiAgICAgICAgICAgICAgPyB7XG4gICAgICAgICAgICAgICAgICBmaWx0ZXJpbmdNb2RpZmllcjoge1xuICAgICAgICAgICAgICAgICAgICBleHRlcm5hbEZpbHRlclF1ZXJ5OiB7XG4gICAgICAgICAgICAgICAgICAgICAgdHlwZXNcbiAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgOiB1bmRlZmluZWRcbiAgICAgICAgICB9KTtcbiAgICAgICAgfSk7XG4gICAgfVxuICB9XG5cbiAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgdGhpcy51bnN1YnNjcmliZSQubmV4dCh0cnVlKTtcbiAgICB0aGlzLnVuc3Vic2NyaWJlJC5jb21wbGV0ZSgpO1xuICB9XG59XG4iLCI8Yzh5LWRldmljZS1ncmlkXG4gIFt0aXRsZV09XCInVGFyZ2V0IGRldmljZXMnIHwgdHJhbnNsYXRlXCJcbiAgW2NvbHVtbnNdPVwiY29sdW1uc1wiXG4gIFtpbmZpbml0ZVNjcm9sbF09XCInYXV0bydcIlxuICBbc2hvd1NlYXJjaF09XCJmYWxzZVwiXG4gIChvbkRldmljZVF1ZXJ5U3RyaW5nQ2hhbmdlKT1cIm9uRGV2aWNlUXVlcnlTdHJpbmdDaGFuZ2UuZW1pdCgkZXZlbnQpXCJcbiAgYzh5UHJvZHVjdEV4cGVyaWVuY2VcbiAgW2FjdGlvbk5hbWVdPVwiJ2J1bGtPcGVyYXRpb25zJ1wiXG4+PC9jOHktZGV2aWNlLWdyaWQ+XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-selector.component.js","sourceRoot":"","sources":["../../../../operations/device-selector/device-selector.component.ts","../../../../operations/device-selector/device-selector.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport {\n  Column,\n  DATA_GRID_CONFIGURATION_CONTEXT,\n  DATA_GRID_CONFIGURATION_STRATEGY,\n  FilteringActionType,\n  UserPreferencesConfigurationStrategy,\n  UserPreferencesGridConfigContext\n} from '@c8y/ngx-components';\nimport {\n  AlarmsDeviceGridColumn,\n  DeviceGridComponent,\n  GroupDeviceGridColumn,\n  ModelDeviceGridColumn,\n  NameDeviceGridColumn,\n  RegistrationDateDeviceGridColumn,\n  StatusDeviceGridColumn,\n  TypeDeviceGridColumn\n} from '@c8y/ngx-components/device-grid';\nimport { Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, takeUntil } from 'rxjs/operators';\n\nconst GRID_CONFIG_KEY = 'device-grid-bulk';\n@Component({\n  selector: 'c8y-device-selector',\n  templateUrl: 'device-selector.component.html',\n  providers: [\n    {\n      provide: DATA_GRID_CONFIGURATION_STRATEGY,\n      useClass: UserPreferencesConfigurationStrategy\n    },\n    {\n      provide: DATA_GRID_CONFIGURATION_CONTEXT,\n      useValue: DeviceSelectorComponent.GRID_CONFIG_CONTEXT\n    }\n  ]\n})\nexport class DeviceSelectorComponent implements OnInit, OnDestroy {\n  static readonly GRID_CONFIG_CONTEXT: UserPreferencesGridConfigContext = {\n    key: GRID_CONFIG_KEY,\n    configFilter: {\n      filter: false\n    }\n  };\n\n  @ViewChild(DeviceGridComponent, { static: true })\n  deviceGrid: DeviceGridComponent;\n\n  @Input()\n  deviceTypes: Observable<string[]>;\n\n  typeColumn: Column = new TypeDeviceGridColumn();\n\n  @Output()\n  onDeviceQueryStringChange: EventEmitter<string> = new EventEmitter<string>();\n\n  columns: Column[] = [\n    new StatusDeviceGridColumn(),\n    new NameDeviceGridColumn(),\n    this.typeColumn,\n    new ModelDeviceGridColumn(),\n    new GroupDeviceGridColumn(),\n    new RegistrationDateDeviceGridColumn(),\n    new AlarmsDeviceGridColumn()\n  ];\n\n  private unsubscribe$: Subject<boolean> = new Subject();\n\n  ngOnInit(): void {\n    if (this.deviceTypes) {\n      this.deviceTypes\n        .pipe(distinctUntilChanged(), takeUntil(this.unsubscribe$))\n        .subscribe((types: string[]) => {\n          // there is a concurrency issue when updateFiltering is called before the columns have actually been passed into the grid\n          // so we are already updating the typeColumn here additionally so in case updateFiltering has no affect, the type column is still correctly filtered\n          // \"Dynamic group created for bulk operation should be invisible\" cypress tests of configurationUpdateBulkOperation.cy.ts started failing otherwise\n          this.typeColumn.externalFilterQuery = { types };\n\n          this.deviceGrid.updateFiltering([this.typeColumn.name], {\n            type:\n              types && types.length\n                ? FilteringActionType.ApplyFilter\n                : FilteringActionType.ResetFilter,\n            payload: types\n              ? {\n                  filteringModifier: {\n                    externalFilterQuery: {\n                      types\n                    }\n                  }\n                }\n              : undefined\n          });\n        });\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.unsubscribe$.next(true);\n    this.unsubscribe$.complete();\n  }\n}\n","<c8y-device-grid\n  [title]=\"'Target devices' | translate\"\n  [columns]=\"columns\"\n  [infiniteScroll]=\"'auto'\"\n  [showSearch]=\"false\"\n  (onDeviceQueryStringChange)=\"onDeviceQueryStringChange.emit($event)\"\n  c8yProductExperience\n  [actionName]=\"'bulkOperations'\"\n></c8y-device-grid>\n"]}