@valtimo/dossier 10.5.1 → 10.6.0

package/esm2020/lib/services/dossier-list-assignee.service.mjs

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, map, switchMap, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./dossier-list.service";
+import * as i2 from "@valtimo/document";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "./dossier-parameter.service";
+export class DossierListAssigneeService {
+    constructor(dossierListService, documentService, translateService, dossierParameterService) {
+        this.dossierListService = dossierListService;
+        this.documentService = documentService;
+        this.translateService = translateService;
+        this.dossierParameterService = dossierParameterService;
+        this.ASSIGNEE_KEY = 'assigneeFullName';
+        this.defaultAssigneeFilter = 'ALL';
+        this.canHaveAssignee$ = this.dossierListService.documentDefinitionName$.pipe(switchMap(documentDefinitionName => this.documentService.getCaseSettings(documentDefinitionName)), map(caseSettings => caseSettings?.canHaveAssignee));
+        this._assigneeFilter$ = new BehaviorSubject(this.defaultAssigneeFilter);
+    }
+    get assigneeFilter$() {
+        return this._assigneeFilter$.asObservable();
+    }
+    resetAssigneeFilter() {
+        this.dossierParameterService.queryAssigneeParam$.pipe(take(1)).subscribe(assigneeParam => {
+            if (assigneeParam) {
+                this._assigneeFilter$.next(assigneeParam);
+                this.dossierParameterService.setAssigneeParameter(assigneeParam);
+            }
+            else {
+                this._assigneeFilter$.next(this.defaultAssigneeFilter);
+                this.dossierParameterService.setAssigneeParameter(this.defaultAssigneeFilter);
+            }
+        });
+    }
+    setAssigneeFilter(assigneeFilter) {
+        this._assigneeFilter$.next(assigneeFilter);
+        this.dossierParameterService.setAssigneeParameter(assigneeFilter);
+    }
+    filterAssigneeColumns(columns, canHaveAssignee) {
+        return columns.filter(column => {
+            if (column?.key === this.ASSIGNEE_KEY && !canHaveAssignee) {
+                return false;
+            }
+            return true;
+        });
+    }
+    addAssigneeListField(columns, listFields, canHaveAssignee) {
+        return [
+            ...listFields,
+            ...(canHaveAssignee && !columns.find(column => column.propertyName === this.ASSIGNEE_KEY)
+                ? [
+                    {
+                        key: this.ASSIGNEE_KEY,
+                        label: this.translateService.instant(`fieldLabels.${this.ASSIGNEE_KEY}`),
+                        sortable: true,
+                        viewType: 'string',
+                    },
+                ]
+                : []),
+        ];
+    }
+}
+DossierListAssigneeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListAssigneeService, deps: [{ token: i1.DossierListService }, { token: i2.DocumentService }, { token: i3.TranslateService }, { token: i4.DossierParameterService }], target: i0.ɵɵFactoryTarget.Injectable });
+DossierListAssigneeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListAssigneeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListAssigneeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DossierListService }, { type: i2.DocumentService }, { type: i3.TranslateService }, { type: i4.DossierParameterService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/dossier-list-pagination.service.mjs

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, filter, map, take, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-logger";
+import * as i2 from "./dossier-parameter.service";
+import * as i3 from "../dossier.service";
+export class DossierListPaginationService {
+    constructor(logger, dossierParameterService, dossierService) {
+        this.logger = logger;
+        this.dossierParameterService = dossierParameterService;
+        this.dossierService = dossierService;
+        this.DEFAULT_PAGINATION = {
+            collectionSize: 0,
+            page: 1,
+            size: 10,
+            maxPaginationItemSize: 5,
+            sort: undefined,
+        };
+        this._pagination$ = new BehaviorSubject(undefined);
+        this._paginationCopy$ = this._pagination$.pipe(filter(pagination => !!pagination), map(pagination => pagination && JSON.parse(JSON.stringify(pagination))), tap(pagination => this.dossierParameterService.setPaginationParameters(pagination)));
+    }
+    get pagination$() {
+        return this._paginationCopy$;
+    }
+    pageChange(newPage) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            if (pagination && pagination.page !== newPage) {
+                this.logger.debug(`Page change: ${newPage}`);
+                this._pagination$.next({ ...pagination, page: newPage });
+            }
+        });
+    }
+    pageSizeChange(newPageSize) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            if (pagination && pagination.size !== newPageSize) {
+                const amountOfAvailablePages = Math.ceil(pagination.collectionSize / newPageSize);
+                const newPage = amountOfAvailablePages < pagination.page ? amountOfAvailablePages : pagination.page;
+                this.logger.debug(`Page size change. New Page: ${newPage} New page size: ${newPageSize}`);
+                this._pagination$.next({ ...pagination, size: newPageSize, page: newPage });
+            }
+        });
+    }
+    sortChanged(newSortState) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            if (pagination && JSON.stringify(pagination.sort) !== JSON.stringify(newSortState)) {
+                this.logger.debug(`Sort state change: ${JSON.stringify(newSortState)}`);
+                this._pagination$.next({ ...pagination, sort: newSortState });
+            }
+        });
+    }
+    setPage(newPageNumber) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            this._pagination$.next({ ...pagination, page: newPageNumber });
+        });
+    }
+    setCollectionSize(documents) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            if (pagination && pagination.collectionSize !== documents.totalElements) {
+                this._pagination$.next({ ...pagination, collectionSize: documents.totalElements });
+            }
+        });
+    }
+    checkPage(documents) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            if (pagination) {
+                const amountOfItems = documents.totalElements;
+                const amountOfPages = Math.ceil(amountOfItems / pagination.size);
+                const currentPage = pagination.page;
+                if (currentPage > amountOfPages) {
+                    this._pagination$.next({ ...pagination, page: amountOfPages });
+                }
+            }
+        });
+    }
+    clearPagination() {
+        this._pagination$.next(undefined);
+    }
+    setPagination(documentDefinitionName, columns) {
+        this.dossierParameterService.queryPaginationParams$
+            .pipe(take(1))
+            .subscribe(queryPaginationParams => {
+            const defaultPagination = this.getDefaultPagination(columns);
+            const paginationToUse = queryPaginationParams || defaultPagination;
+            this.logger.debug(`Set pagination: ${JSON.stringify(paginationToUse)}`);
+            this._pagination$.next(paginationToUse);
+        });
+    }
+    getDefaultPagination(columns) {
+        const defaultSortState = this.dossierService.getInitialSortState(columns);
+        return {
+            ...this.DEFAULT_PAGINATION,
+            sort: defaultSortState,
+        };
+    }
+}
+DossierListPaginationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListPaginationService, deps: [{ token: i1.NGXLogger }, { token: i2.DossierParameterService }, { token: i3.DossierService }], target: i0.ɵɵFactoryTarget.Injectable });
+DossierListPaginationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListPaginationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListPaginationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NGXLogger }, { type: i2.DossierParameterService }, { type: i3.DossierService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dossier-list-pagination.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/dossier/src/lib/services/dossier-list-pagination.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable} from '@angular/core';\nimport {BehaviorSubject, filter, map, Observable, take, tap} from 'rxjs';\nimport {Pagination} from '@valtimo/components';\nimport {NGXLogger} from 'ngx-logger';\nimport {DossierParameterService} from './dossier-parameter.service';\nimport {DefinitionColumn} from '@valtimo/config';\nimport {DossierService} from '../dossier.service';\nimport {Documents, SortState, SpecifiedDocuments} from '@valtimo/document';\n\n@Injectable()\nexport class DossierListPaginationService {\n  private readonly DEFAULT_PAGINATION: Pagination = {\n    collectionSize: 0,\n    page: 1,\n    size: 10,\n    maxPaginationItemSize: 5,\n    sort: undefined,\n  };\n\n  private readonly _pagination$ = new BehaviorSubject<Pagination | undefined>(undefined);\n\n  private readonly _paginationCopy$ = this._pagination$.pipe(\n    filter(pagination => !!pagination),\n    map(pagination => pagination && JSON.parse(JSON.stringify(pagination))),\n    tap(pagination => this.dossierParameterService.setPaginationParameters(pagination))\n  );\n\n  get pagination$(): Observable<Pagination> {\n    return this._paginationCopy$;\n  }\n\n  constructor(\n    private readonly logger: NGXLogger,\n    private readonly dossierParameterService: DossierParameterService,\n    private readonly dossierService: DossierService\n  ) {}\n\n  pageChange(newPage: number): void {\n    this._pagination$.pipe(take(1)).subscribe(pagination => {\n      if (pagination && pagination.page !== newPage) {\n        this.logger.debug(`Page change: ${newPage}`);\n        this._pagination$.next({...pagination, page: newPage});\n      }\n    });\n  }\n\n  pageSizeChange(newPageSize: number): void {\n    this._pagination$.pipe(take(1)).subscribe(pagination => {\n      if (pagination && pagination.size !== newPageSize) {\n        const amountOfAvailablePages = Math.ceil(pagination.collectionSize / newPageSize);\n        const newPage =\n          amountOfAvailablePages < pagination.page ? amountOfAvailablePages : pagination.page;\n\n        this.logger.debug(`Page size change. New Page: ${newPage} New page size: ${newPageSize}`);\n        this._pagination$.next({...pagination, size: newPageSize, page: newPage});\n      }\n    });\n  }\n\n  sortChanged(newSortState: SortState): void {\n    this._pagination$.pipe(take(1)).subscribe(pagination => {\n      if (pagination && JSON.stringify(pagination.sort) !== JSON.stringify(newSortState)) {\n        this.logger.debug(`Sort state change: ${JSON.stringify(newSortState)}`);\n        this._pagination$.next({...pagination, sort: newSortState});\n      }\n    });\n  }\n\n  setPage(newPageNumber: number): void {\n    this._pagination$.pipe(take(1)).subscribe(pagination => {\n      this._pagination$.next({...pagination, page: newPageNumber});\n    });\n  }\n\n  setCollectionSize(documents: Documents | SpecifiedDocuments): void {\n    this._pagination$.pipe(take(1)).subscribe(pagination => {\n      if (pagination && pagination.collectionSize !== documents.totalElements) {\n        this._pagination$.next({...pagination, collectionSize: documents.totalElements});\n      }\n    });\n  }\n\n  checkPage(documents: Documents | SpecifiedDocuments): void {\n    this._pagination$.pipe(take(1)).subscribe(pagination => {\n      if (pagination) {\n        const amountOfItems = documents.totalElements;\n        const amountOfPages = Math.ceil(amountOfItems / pagination.size);\n        const currentPage = pagination.page;\n\n        if (currentPage > amountOfPages) {\n          this._pagination$.next({...pagination, page: amountOfPages});\n        }\n      }\n    });\n  }\n\n  clearPagination(): void {\n    this._pagination$.next(undefined);\n  }\n\n  setPagination(documentDefinitionName: string, columns: Array<DefinitionColumn>): void {\n    this.dossierParameterService.queryPaginationParams$\n      .pipe(take(1))\n      .subscribe(queryPaginationParams => {\n        const defaultPagination: Pagination = this.getDefaultPagination(columns);\n        const paginationToUse = queryPaginationParams || defaultPagination;\n\n        this.logger.debug(`Set pagination: ${JSON.stringify(paginationToUse)}`);\n\n        this._pagination$.next(paginationToUse);\n      });\n  }\n\n  private getDefaultPagination(columns: Array<DefinitionColumn>): Pagination {\n    const defaultSortState = this.dossierService.getInitialSortState(columns);\n\n    return {\n      ...this.DEFAULT_PAGINATION,\n      sort: defaultSortState,\n    };\n  }\n}\n"]}

package/esm2020/lib/services/dossier-list-search.service.mjs

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, switchMap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./dossier-list.service";
+import * as i2 from "@valtimo/document";
+import * as i3 from "./dossier-parameter.service";
+export class DossierListSearchService {
+    constructor(dossierListService, documentService, dossierParameterService) {
+        this.dossierListService = dossierListService;
+        this.documentService = documentService;
+        this.dossierParameterService = dossierParameterService;
+        this._searchSwitch$ = new BehaviorSubject(false);
+        this._documentSearchFields$ = this.dossierListService.documentDefinitionName$.pipe(switchMap(documentDefinitionName => this.documentService.getDocumentSearchFields(documentDefinitionName)));
+    }
+    get searchSwitch$() {
+        return this._searchSwitch$.asObservable();
+    }
+    get documentSearchFields$() {
+        return this._documentSearchFields$;
+    }
+    search(searchFieldValues) {
+        this.dossierParameterService.setSearchFieldValues(searchFieldValues || {});
+        this.dossierParameterService.setSearchParameters(searchFieldValues);
+        this._searchSwitch$.next(!this._searchSwitch$.getValue());
+    }
+    refresh() {
+        this._searchSwitch$.next(!this._searchSwitch$.getValue());
+    }
+    mapSearchValuesToFilters(values) {
+        const filters = [];
+        Object.keys(values).forEach(valueKey => {
+            const searchValue = values[valueKey];
+            if (searchValue.start) {
+                filters.push({ key: valueKey, rangeFrom: searchValue.start, rangeTo: searchValue.end });
+            }
+            else if (Array.isArray(searchValue)) {
+                filters.push({ key: valueKey, values: searchValue });
+            }
+            else {
+                filters.push({ key: valueKey, values: [searchValue] });
+            }
+        });
+        return filters;
+    }
+}
+DossierListSearchService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListSearchService, deps: [{ token: i1.DossierListService }, { token: i2.DocumentService }, { token: i3.DossierParameterService }], target: i0.ɵɵFactoryTarget.Injectable });
+DossierListSearchService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListSearchService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListSearchService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DossierListService }, { type: i2.DocumentService }, { type: i3.DossierParameterService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/dossier-list.service.mjs

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../services";
+export class DossierListService {
+    constructor(dossierColumnService) {
+        this.dossierColumnService = dossierColumnService;
+        this._documentDefinitionName$ = new BehaviorSubject('');
+        this._hasEnvColumnConfig$ = this.documentDefinitionName$.pipe(map(documentDefinitionName => this.dossierColumnService.hasEnvironmentConfig(documentDefinitionName)));
+    }
+    get documentDefinitionName$() {
+        return this._documentDefinitionName$.asObservable();
+    }
+    get hasEnvColumnConfig$() {
+        return this._hasEnvColumnConfig$;
+    }
+    setDocumentDefinitionName(documentDefinitionName) {
+        this._documentDefinitionName$.next(documentDefinitionName);
+    }
+    mapDocuments(documents, hasEnvColumnConfig, hasApiColumnConfig) {
+        if (hasEnvColumnConfig || !hasApiColumnConfig) {
+            const docsToMap = documents;
+            return docsToMap.content.map(document => {
+                const { content, ...others } = document;
+                return { ...content, ...others };
+            });
+        }
+        else {
+            const docsToMap = documents;
+            return docsToMap.content.reduce((acc, curr) => {
+                const propsObject = { id: curr.id };
+                curr.items?.forEach(item => {
+                    propsObject[item.key] = item.value;
+                });
+                return [...acc, propsObject];
+            }, []);
+        }
+    }
+}
+DossierListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListService, deps: [{ token: i1.DossierColumnService }], target: i0.ɵɵFactoryTarget.Injectable });
+DossierListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DossierColumnService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/dossier-parameter.service.mjs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Injectable } from '@angular/core';
-import { BehaviorSubject, combineLatest, distinctUntilChanged, filter, map, startWith, take, } from 'rxjs';
+import { BehaviorSubject, combineLatest, distinctUntilChanged, map, take, } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
 export class DossierParameterService {
@@ -22,11 +22,15 @@ export class DossierParameterService {
         this.router = router;
         this.route = route;
         this._dossierParameters$ = new BehaviorSubject(undefined);
-        this.openDossierParametersSubscription();
+        this._searchFieldValues$ = new BehaviorSubject({});
+        this.setDossierParameters();
     }
     get dossierParameters$() {
         return this._dossierParameters$.asObservable();
     }
+    get searchFieldValues$() {
+        return this._searchFieldValues$.asObservable();
+    }
     get querySearchParams$() {
         return this.route.queryParams.pipe(map(params => {
             if (params.search) {
@@ -36,29 +40,44 @@ export class DossierParameterService {
         }), distinctUntilChanged((prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)));
     }
     get queryPaginationParams$() {
-        return this.route.queryParams.pipe(filter(params => params.collectionSize), map(params => {
+        return this.route.queryParams.pipe(map(params => {
             const paramsCopy = { ...params };
             if (paramsCopy.search) {
                 delete paramsCopy.search;
             }
-            return {
-                collectionSize: Number(paramsCopy.collectionSize),
-                page: Number(paramsCopy.page),
-                size: Number(paramsCopy.size),
-                maxPaginationItemSize: Number(paramsCopy.maxPaginationItemSize),
-                ...(paramsCopy.isSorting === 'true' && {
-                    isSorting: !!(paramsCopy.isSorting === 'true'),
-                    state: {
-                        name: paramsCopy.sortStateName,
-                        direction: paramsCopy.sortStateDirection,
-                    },
-                }),
-            };
-        }), distinctUntilChanged((prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)), startWith(null));
+            return paramsCopy.collectionSize
+                ? {
+                    collectionSize: Number(paramsCopy.collectionSize),
+                    page: Number(paramsCopy.page),
+                    size: Number(paramsCopy.size),
+                    maxPaginationItemSize: Number(paramsCopy.maxPaginationItemSize),
+                    ...(paramsCopy.isSorting === 'true' && {
+                        sort: {
+                            isSorting: !!(paramsCopy.isSorting === 'true'),
+                            state: {
+                                name: paramsCopy.sortStateName,
+                                direction: paramsCopy.sortStateDirection,
+                            },
+                        },
+                    }),
+                }
+                : null;
+        }), distinctUntilChanged((prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)));
+    }
+    get queryAssigneeParam$() {
+        return this.route.queryParams.pipe(map(params => {
+            if (params?.assignee) {
+                return params?.assignee?.toUpperCase();
+            }
+            return '';
+        }), distinctUntilChanged((prevParams, currParams) => prevParams === currParams));
     }
     ngOnDestroy() {
         this.dossierParametersSubscription?.unsubscribe();
     }
+    setSearchFieldValues(searchFieldValues) {
+        this._searchFieldValues$.next(searchFieldValues);
+    }
     setSearchParameters(searchParameters) {
         this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {
             if (Object.keys(searchParameters || {}).length > 0) {
@@ -93,20 +112,24 @@ export class DossierParameterService {
             });
         }
     }
+    setAssigneeParameter(assigneeFilter) {
+        this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {
+            this._dossierParameters$.next({
+                ...dossierParameters,
+                assignee: assigneeFilter.toLowerCase(),
+            });
+        });
+    }
+    clearSearchFieldValues() {
+        this._searchFieldValues$.next({});
+    }
+    clearParameters() {
+        this._dossierParameters$.next(undefined);
+        this.router.navigate([this.getUrlWithoutParams()]);
+    }
     openDossierParametersSubscription() {
-        this.dossierParametersSubscription = combineLatest([
-            this.dossierParameters$,
-            this.route.queryParams,
-        ]).subscribe(([dossierParams, queryParams]) => {
-            let paramsToUse = {};
-            if (Object.keys(queryParams || {}).length > 0 &&
-                Object.keys(dossierParams || {}).length === 0) {
-                paramsToUse = queryParams;
-            }
-            else {
-                paramsToUse = dossierParams;
-            }
-            this.router.navigate([this.getUrlWithoutParams()], { queryParams: paramsToUse });
+        this.dossierParametersSubscription = this.dossierParameters$.subscribe(dossierParams => {
+            this.router.navigate([this.getUrlWithoutParams()], { queryParams: dossierParams });
         });
     }
     objectToBase64(jsObject) {
@@ -118,10 +141,27 @@ export class DossierParameterService {
         urlTree.fragment = null;
         return urlTree.toString();
     }
+    setDossierParameters() {
+        combineLatest([this.queryPaginationParams$, this.querySearchParams$, this.queryAssigneeParam$])
+            .pipe(take(1))
+            .subscribe(([paginationParams, searchParams, assigneeParams]) => {
+            if (paginationParams) {
+                this.setPaginationParameters(paginationParams);
+            }
+            if (searchParams) {
+                this.setSearchParameters(searchParams);
+                this.setSearchFieldValues(searchParams);
+            }
+            if (assigneeParams) {
+                this.setAssigneeParameter(assigneeParams);
+            }
+            this.openDossierParametersSubscription();
+        });
+    }
 }
 DossierParameterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierParameterService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
 DossierParameterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierParameterService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DossierParameterService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dossier-parameter.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/dossier/src/lib/services/dossier-parameter.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {DossierParameters} from '../models';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  distinctUntilChanged,\n  filter,\n  map,\n  Observable,\n  startWith,\n  Subscription,\n  take,\n} from 'rxjs';\nimport {ActivatedRoute, Router} from '@angular/router';\nimport {Direction, SearchFieldValues} from '@valtimo/config';\nimport {Pagination} from '@valtimo/components';\n\n@Injectable()\nexport class DossierParameterService implements OnDestroy {\n  private readonly _dossierParameters$ = new BehaviorSubject<DossierParameters>(undefined);\n\n  get dossierParameters$(): Observable<DossierParameters> {\n    return this._dossierParameters$.asObservable();\n  }\n\n  get querySearchParams$(): Observable<SearchFieldValues> {\n    return this.route.queryParams.pipe(\n      map(params => {\n        if (params.search) {\n          return JSON.parse(atob(params.search)) as SearchFieldValues;\n        }\n        return {};\n      }),\n      distinctUntilChanged(\n        (prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)\n      )\n    );\n  }\n\n  get queryPaginationParams$(): Observable<Pagination | null> {\n    return this.route.queryParams.pipe(\n      filter(params => params.collectionSize),\n      map(params => {\n        const paramsCopy = {...params} as any as DossierParameters;\n\n        if (paramsCopy.search) {\n          delete paramsCopy.search;\n        }\n\n        return {\n          collectionSize: Number(paramsCopy.collectionSize),\n          page: Number(paramsCopy.page),\n          size: Number(paramsCopy.size),\n          maxPaginationItemSize: Number(paramsCopy.maxPaginationItemSize),\n          ...(paramsCopy.isSorting === 'true' && {\n            isSorting: !!(paramsCopy.isSorting === 'true'),\n            state: {\n              name: paramsCopy.sortStateName,\n              direction: paramsCopy.sortStateDirection as Direction,\n            },\n          }),\n        };\n      }),\n      distinctUntilChanged(\n        (prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)\n      ),\n      startWith(null)\n    );\n  }\n\n  dossierParametersSubscription!: Subscription;\n\n  constructor(private readonly router: Router, private readonly route: ActivatedRoute) {\n    this.openDossierParametersSubscription();\n  }\n\n  ngOnDestroy(): void {\n    this.dossierParametersSubscription?.unsubscribe();\n  }\n\n  setSearchParameters(searchParameters: SearchFieldValues): void {\n    this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {\n      if (Object.keys(searchParameters || {}).length > 0) {\n        this._dossierParameters$.next({\n          ...dossierParameters,\n          search: this.objectToBase64(searchParameters),\n        });\n      } else {\n        if (dossierParameters?.search) {\n          delete dossierParameters.search;\n        }\n        this._dossierParameters$.next(dossierParameters);\n      }\n    });\n  }\n\n  setPaginationParameters(pagination: Pagination): void {\n    if (pagination) {\n      this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {\n        this._dossierParameters$.next({\n          ...dossierParameters,\n          size: `${pagination.size}`,\n          collectionSize: `${pagination.collectionSize}`,\n          page: `${pagination.page}`,\n          maxPaginationItemSize: `${pagination.maxPaginationItemSize}`,\n          isSorting: pagination.sort?.isSorting ? 'true' : 'false',\n          ...(pagination.sort?.state?.name && {sortStateName: `${pagination.sort?.state.name}`}),\n          ...(pagination.sort?.state?.direction && {\n            sortStateDirection: `${pagination.sort?.state.direction}`,\n          }),\n        });\n      });\n    }\n  }\n\n  private openDossierParametersSubscription(): void {\n    this.dossierParametersSubscription = combineLatest([\n      this.dossierParameters$,\n      this.route.queryParams,\n    ]).subscribe(([dossierParams, queryParams]) => {\n      let paramsToUse = {};\n\n      if (\n        Object.keys(queryParams || {}).length > 0 &&\n        Object.keys(dossierParams || {}).length === 0\n      ) {\n        paramsToUse = queryParams;\n      } else {\n        paramsToUse = dossierParams;\n      }\n\n      this.router.navigate([this.getUrlWithoutParams()], {queryParams: paramsToUse});\n    });\n  }\n\n  private objectToBase64(jsObject: object): string {\n    return btoa(JSON.stringify(jsObject));\n  }\n\n  private getUrlWithoutParams(): string {\n    const urlTree = this.router.parseUrl(this.router.url);\n    urlTree.queryParams = {};\n    urlTree.fragment = null;\n    return urlTree.toString();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dossier-parameter.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/dossier/src/lib/services/dossier-parameter.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {DossierParameters} from '../models';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  distinctUntilChanged,\n  map,\n  Observable,\n  Subscription,\n  take,\n} from 'rxjs';\nimport {ActivatedRoute, Router} from '@angular/router';\nimport {AssigneeFilter, Direction, SearchFieldValues} from '@valtimo/config';\nimport {Pagination} from '@valtimo/components';\n\n@Injectable()\nexport class DossierParameterService implements OnDestroy {\n  private readonly _dossierParameters$ = new BehaviorSubject<DossierParameters>(undefined);\n  private readonly _searchFieldValues$ = new BehaviorSubject<SearchFieldValues>({});\n\n  get dossierParameters$(): Observable<DossierParameters> {\n    return this._dossierParameters$.asObservable();\n  }\n\n  get searchFieldValues$(): Observable<SearchFieldValues> {\n    return this._searchFieldValues$.asObservable();\n  }\n\n  get querySearchParams$(): Observable<SearchFieldValues> {\n    return this.route.queryParams.pipe(\n      map(params => {\n        if (params.search) {\n          return JSON.parse(atob(params.search)) as SearchFieldValues;\n        }\n        return {};\n      }),\n      distinctUntilChanged(\n        (prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)\n      )\n    );\n  }\n\n  get queryPaginationParams$(): Observable<Pagination | null> {\n    return this.route.queryParams.pipe(\n      map(params => {\n        const paramsCopy = {...params} as any as DossierParameters;\n\n        if (paramsCopy.search) {\n          delete paramsCopy.search;\n        }\n\n        return paramsCopy.collectionSize\n          ? {\n              collectionSize: Number(paramsCopy.collectionSize),\n              page: Number(paramsCopy.page),\n              size: Number(paramsCopy.size),\n              maxPaginationItemSize: Number(paramsCopy.maxPaginationItemSize),\n              ...(paramsCopy.isSorting === 'true' && {\n                sort: {\n                  isSorting: !!(paramsCopy.isSorting === 'true'),\n                  state: {\n                    name: paramsCopy.sortStateName,\n                    direction: paramsCopy.sortStateDirection as Direction,\n                  },\n                },\n              }),\n            }\n          : null;\n      }),\n      distinctUntilChanged(\n        (prevParams, currParams) => JSON.stringify(prevParams) === JSON.stringify(currParams)\n      )\n    );\n  }\n\n  get queryAssigneeParam$(): Observable<AssigneeFilter> {\n    return this.route.queryParams.pipe(\n      map(params => {\n        if (params?.assignee) {\n          return params?.assignee?.toUpperCase();\n        }\n        return '';\n      }),\n      distinctUntilChanged((prevParams, currParams) => prevParams === currParams)\n    );\n  }\n\n  dossierParametersSubscription!: Subscription;\n\n  constructor(private readonly router: Router, private readonly route: ActivatedRoute) {\n    this.setDossierParameters();\n  }\n\n  ngOnDestroy(): void {\n    this.dossierParametersSubscription?.unsubscribe();\n  }\n\n  setSearchFieldValues(searchFieldValues: SearchFieldValues): void {\n    this._searchFieldValues$.next(searchFieldValues);\n  }\n\n  setSearchParameters(searchParameters: SearchFieldValues): void {\n    this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {\n      if (Object.keys(searchParameters || {}).length > 0) {\n        this._dossierParameters$.next({\n          ...dossierParameters,\n          search: this.objectToBase64(searchParameters),\n        });\n      } else {\n        if (dossierParameters?.search) {\n          delete dossierParameters.search;\n        }\n        this._dossierParameters$.next(dossierParameters);\n      }\n    });\n  }\n\n  setPaginationParameters(pagination: Pagination): void {\n    if (pagination) {\n      this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {\n        this._dossierParameters$.next({\n          ...dossierParameters,\n          size: `${pagination.size}`,\n          collectionSize: `${pagination.collectionSize}`,\n          page: `${pagination.page}`,\n          maxPaginationItemSize: `${pagination.maxPaginationItemSize}`,\n          isSorting: pagination.sort?.isSorting ? 'true' : 'false',\n          ...(pagination.sort?.state?.name && {sortStateName: `${pagination.sort?.state.name}`}),\n          ...(pagination.sort?.state?.direction && {\n            sortStateDirection: `${pagination.sort?.state.direction}`,\n          }),\n        });\n      });\n    }\n  }\n\n  setAssigneeParameter(assigneeFilter: AssigneeFilter): void {\n    this._dossierParameters$.pipe(take(1)).subscribe(dossierParameters => {\n      this._dossierParameters$.next({\n        ...dossierParameters,\n        assignee: assigneeFilter.toLowerCase(),\n      });\n    });\n  }\n\n  clearSearchFieldValues(): void {\n    this._searchFieldValues$.next({});\n  }\n\n  clearParameters(): void {\n    this._dossierParameters$.next(undefined);\n    this.router.navigate([this.getUrlWithoutParams()]);\n  }\n\n  private openDossierParametersSubscription(): void {\n    this.dossierParametersSubscription = this.dossierParameters$.subscribe(dossierParams => {\n      this.router.navigate([this.getUrlWithoutParams()], {queryParams: dossierParams});\n    });\n  }\n\n  private objectToBase64(jsObject: object): string {\n    return btoa(JSON.stringify(jsObject));\n  }\n\n  private getUrlWithoutParams(): string {\n    const urlTree = this.router.parseUrl(this.router.url);\n    urlTree.queryParams = {};\n    urlTree.fragment = null;\n    return urlTree.toString();\n  }\n\n  private setDossierParameters(): void {\n    combineLatest([this.queryPaginationParams$, this.querySearchParams$, this.queryAssigneeParam$])\n      .pipe(take(1))\n      .subscribe(([paginationParams, searchParams, assigneeParams]) => {\n        if (paginationParams) {\n          this.setPaginationParameters(paginationParams);\n        }\n        if (searchParams) {\n          this.setSearchParameters(searchParams);\n          this.setSearchFieldValues(searchParams);\n        }\n        if (assigneeParams) {\n          this.setAssigneeParameter(assigneeParams);\n        }\n\n        this.openDossierParametersSubscription();\n      });\n  }\n}\n"]}

package/esm2020/lib/services/index.mjs

@@ -17,4 +17,8 @@ export * from './dossier-column.service';
 export * from './zaakobjecten.service';
 export * from './dossier-parameter.service';
 export * from './file-sort.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Rvc3NpZXIvc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2Rvc3NpZXItY29sdW1uLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi96YWFrb2JqZWN0ZW4uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rvc3NpZXItcGFyYW1ldGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9maWxlLXNvcnQuc2VydmljZSc7XG4iXX0=
+export * from './dossier-list.service';
+export * from './dossier-list-assignee.service';
+export * from './dossier-list-pagination.service';
+export * from './dossier-list-search.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Rvc3NpZXIvc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIzIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZG9zc2llci1jb2x1bW4uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3phYWtvYmplY3Rlbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZG9zc2llci1wYXJhbWV0ZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGUtc29ydC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZG9zc2llci1saXN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kb3NzaWVyLWxpc3QtYXNzaWduZWUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rvc3NpZXItbGlzdC1wYWdpbmF0aW9uLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kb3NzaWVyLWxpc3Qtc2VhcmNoLnNlcnZpY2UnO1xuIl19