@valtimo/task 11.3.2 → 12.1.0

package/esm2022/lib/models/task-list-search-field.model.mjs

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2015-2024 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.
+ */
+var TaskListSearchFieldDataType;
+(function (TaskListSearchFieldDataType) {
+    TaskListSearchFieldDataType["TEXT"] = "text";
+    TaskListSearchFieldDataType["NUMBER"] = "number";
+    TaskListSearchFieldDataType["DATE"] = "date";
+    TaskListSearchFieldDataType["DATETIME"] = "datetime";
+    TaskListSearchFieldDataType["TIME"] = "time";
+    TaskListSearchFieldDataType["BOOLEAN"] = "boolean";
+})(TaskListSearchFieldDataType || (TaskListSearchFieldDataType = {}));
+var TaskListSearchFieldFieldType;
+(function (TaskListSearchFieldFieldType) {
+    TaskListSearchFieldFieldType["SINGLE"] = "single";
+    TaskListSearchFieldFieldType["RANGE"] = "range";
+    TaskListSearchFieldFieldType["SINGLE_SELECT_DROPDOWN"] = "single_select_dropdown";
+    TaskListSearchFieldFieldType["MULTI_SELECT_DROPDOWN"] = "multi_select_dropdown";
+})(TaskListSearchFieldFieldType || (TaskListSearchFieldFieldType = {}));
+var TaskListSearchFieldMatchType;
+(function (TaskListSearchFieldMatchType) {
+    TaskListSearchFieldMatchType["LIKE"] = "like";
+    TaskListSearchFieldMatchType["EXACT"] = "exact";
+})(TaskListSearchFieldMatchType || (TaskListSearchFieldMatchType = {}));
+var TaskListSearchDropdownDataProvider;
+(function (TaskListSearchDropdownDataProvider) {
+    TaskListSearchDropdownDataProvider["DATABASE"] = "dropdownDatabaseDataProvider";
+    TaskListSearchDropdownDataProvider["JSON"] = "dropdownJsonFileDataProvider";
+})(TaskListSearchDropdownDataProvider || (TaskListSearchDropdownDataProvider = {}));
+export { TaskListSearchDropdownDataProvider, TaskListSearchFieldDataType, TaskListSearchFieldFieldType, TaskListSearchFieldMatchType, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1saXN0LXNlYXJjaC1maWVsZC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vdGFzay9zcmMvbGliL21vZGVscy90YXNrLWxpc3Qtc2VhcmNoLWZpZWxkLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsSUFBSywyQkFPSjtBQVBELFdBQUssMkJBQTJCO0lBQzlCLDRDQUFhLENBQUE7SUFDYixnREFBaUIsQ0FBQTtJQUNqQiw0Q0FBYSxDQUFBO0lBQ2Isb0RBQXFCLENBQUE7SUFDckIsNENBQWEsQ0FBQTtJQUNiLGtEQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFQSSwyQkFBMkIsS0FBM0IsMkJBQTJCLFFBTy9CO0FBRUQsSUFBSyw0QkFLSjtBQUxELFdBQUssNEJBQTRCO0lBQy9CLGlEQUFpQixDQUFBO0lBQ2pCLCtDQUFlLENBQUE7SUFDZixpRkFBaUQsQ0FBQTtJQUNqRCwrRUFBK0MsQ0FBQTtBQUNqRCxDQUFDLEVBTEksNEJBQTRCLEtBQTVCLDRCQUE0QixRQUtoQztBQUVELElBQUssNEJBR0o7QUFIRCxXQUFLLDRCQUE0QjtJQUMvQiw2Q0FBYSxDQUFBO0lBQ2IsK0NBQWUsQ0FBQTtBQUNqQixDQUFDLEVBSEksNEJBQTRCLEtBQTVCLDRCQUE0QixRQUdoQztBQUVELElBQUssa0NBR0o7QUFIRCxXQUFLLGtDQUFrQztJQUNyQywrRUFBeUMsQ0FBQTtJQUN6QywyRUFBcUMsQ0FBQTtBQUN2QyxDQUFDLEVBSEksa0NBQWtDLEtBQWxDLGtDQUFrQyxRQUd0QztBQW9CRCxPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDJCQUEyQixFQUMzQiw0QkFBNEIsRUFDNUIsNEJBQTRCLEdBRzdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyNCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5lbnVtIFRhc2tMaXN0U2VhcmNoRmllbGREYXRhVHlwZSB7XG4gIFRFWFQgPSAndGV4dCcsXG4gIE5VTUJFUiA9ICdudW1iZXInLFxuICBEQVRFID0gJ2RhdGUnLFxuICBEQVRFVElNRSA9ICdkYXRldGltZScsXG4gIFRJTUUgPSAndGltZScsXG4gIEJPT0xFQU4gPSAnYm9vbGVhbicsXG59XG5cbmVudW0gVGFza0xpc3RTZWFyY2hGaWVsZEZpZWxkVHlwZSB7XG4gIFNJTkdMRSA9ICdzaW5nbGUnLFxuICBSQU5HRSA9ICdyYW5nZScsXG4gIFNJTkdMRV9TRUxFQ1RfRFJPUERPV04gPSAnc2luZ2xlX3NlbGVjdF9kcm9wZG93bicsXG4gIE1VTFRJX1NFTEVDVF9EUk9QRE9XTiA9ICdtdWx0aV9zZWxlY3RfZHJvcGRvd24nLFxufVxuXG5lbnVtIFRhc2tMaXN0U2VhcmNoRmllbGRNYXRjaFR5cGUge1xuICBMSUtFID0gJ2xpa2UnLFxuICBFWEFDVCA9ICdleGFjdCcsXG59XG5cbmVudW0gVGFza0xpc3RTZWFyY2hEcm9wZG93bkRhdGFQcm92aWRlciB7XG4gIERBVEFCQVNFID0gJ2Ryb3Bkb3duRGF0YWJhc2VEYXRhUHJvdmlkZXInLFxuICBKU09OID0gJ2Ryb3Bkb3duSnNvbkZpbGVEYXRhUHJvdmlkZXInLFxufVxuXG5pbnRlcmZhY2UgVGFza0xpc3RTZWFyY2hGaWVsZCB7XG4gIGlkOiBzdHJpbmc7XG4gIG93bmVySWQ6IHN0cmluZztcbiAgZGF0YVR5cGU6IFRhc2tMaXN0U2VhcmNoRmllbGREYXRhVHlwZTtcbiAgZmllbGRUeXBlOiBUYXNrTGlzdFNlYXJjaEZpZWxkRmllbGRUeXBlO1xuICBrZXk6IHN0cmluZztcbiAgdGl0bGU/OiBzdHJpbmc7XG4gIHBhdGg6IHN0cmluZztcbiAgb3JkZXI6IG51bWJlcjtcbiAgbWF0Y2hUeXBlOiBUYXNrTGlzdFNlYXJjaEZpZWxkTWF0Y2hUeXBlO1xuICBkcm9wZG93bkRhdGFQcm92aWRlcj86IHN0cmluZztcbiAgZHJvcGRvd25WYWx1ZXM/OiBUYXNrTGlzdFNlYXJjaERyb3Bkb3duVmFsdWU7XG59XG5cbmludGVyZmFjZSBUYXNrTGlzdFNlYXJjaERyb3Bkb3duVmFsdWUge1xuICBba2V5OiBzdHJpbmddOiBzdHJpbmc7XG59XG5cbmV4cG9ydCB7XG4gIFRhc2tMaXN0U2VhcmNoRHJvcGRvd25EYXRhUHJvdmlkZXIsXG4gIFRhc2tMaXN0U2VhcmNoRmllbGREYXRhVHlwZSxcbiAgVGFza0xpc3RTZWFyY2hGaWVsZEZpZWxkVHlwZSxcbiAgVGFza0xpc3RTZWFyY2hGaWVsZE1hdGNoVHlwZSxcbiAgVGFza0xpc3RTZWFyY2hGaWVsZCxcbiAgVGFza0xpc3RTZWFyY2hEcm9wZG93blZhbHVlLFxufTtcbiJdfQ==

package/esm2022/lib/models/task-list.model.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,16 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export class TaskList {
-    constructor() {
-        this.tasks = [];
-        this.fields = [];
-        this.pagination = {
-            collectionSize: 0,
-            page: 1,
-            size: 10,
-        };
-        this.page = 0;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1saXN0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmFsdGltby90YXNrL3NyYy9saWIvbW9kZWxzL3Rhc2stbGlzdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILE1BQU0sT0FBTyxRQUFRO0lBQXJCO1FBQ1MsVUFBSyxHQUFHLEVBQUUsQ0FBQztRQUNsQixXQUFNLEdBQUcsRUFBRSxDQUFDO1FBQ1osZUFBVSxHQUFHO1lBQ1gsY0FBYyxFQUFFLENBQUM7WUFDakIsSUFBSSxFQUFFLENBQUM7WUFDUCxJQUFJLEVBQUUsRUFBRTtTQUNULENBQUM7UUFDRixTQUFJLEdBQUcsQ0FBQyxDQUFDO0lBQ1gsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjMgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGNsYXNzIFRhc2tMaXN0IHtcbiAgcHVibGljIHRhc2tzID0gW107XG4gIGZpZWxkcyA9IFtdO1xuICBwYWdpbmF0aW9uID0ge1xuICAgIGNvbGxlY3Rpb25TaXplOiAwLFxuICAgIHBhZ2U6IDEsXG4gICAgc2l6ZTogMTAsXG4gIH07XG4gIHBhZ2UgPSAwO1xufVxuIl19
+var TaskListColumnDefaultSort;
+(function (TaskListColumnDefaultSort) {
+    TaskListColumnDefaultSort["ASC"] = "ASC";
+    TaskListColumnDefaultSort["DESC"] = "DESC";
+})(TaskListColumnDefaultSort || (TaskListColumnDefaultSort = {}));
+export { TaskListColumnDefaultSort, };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/task.model.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2015-2024 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.
+ */
+export * from './task.service';
+export * from './task-list.service';
+export * from './task-list-column.service';
+export * from './task-list-pagination.service';
+export * from './task-list-search.service';
+export * from './task-list-query-param.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3Rhc2svc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjQgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi90YXNrLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YXNrLWxpc3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Rhc2stbGlzdC1jb2x1bW4uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Rhc2stbGlzdC1wYWdpbmF0aW9uLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YXNrLWxpc3Qtc2VhcmNoLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YXNrLWxpc3QtcXVlcnktcGFyYW0uc2VydmljZSc7XG4iXX0=

package/esm2022/lib/services/task-intermediate-save.service.mjs

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2015-2024 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 { HttpHeaders } from '@angular/common/http';
+import { BaseApiService, } from '@valtimo/config';
+import { InterceptorSkip } from '@valtimo/security';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@valtimo/config";
+export class TaskIntermediateSaveService extends BaseApiService {
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getIntermediateSubmission(taskInstanceId) {
+        return this.httpClient.get(this.getApiUrl('/v1/form/intermediate/submission'), {
+            params: {
+                taskInstanceId,
+            },
+            headers: new HttpHeaders().set(InterceptorSkip, '404'),
+        });
+    }
+    storeIntermediateSubmission(request) {
+        return this.httpClient.post(this.getApiUrl('/v1/form/intermediate/submission'), request, {
+            headers: new HttpHeaders().set(InterceptorSkip, '400'),
+        });
+    }
+    clearIntermediateSubmission(taskInstanceId) {
+        return this.httpClient.delete(this.getApiUrl('/v1/form/intermediate/submission'), {
+            params: {
+                taskInstanceId,
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskIntermediateSaveService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskIntermediateSaveService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskIntermediateSaveService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/task-list-column.service.mjs

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2015-2024 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 { ViewType } from '@valtimo/components';
+import { BehaviorSubject, filter, switchMap, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./task.service";
+import * as i2 from "./task-list.service";
+import * as i3 from "./task-list-sort.service";
+export class TaskListColumnService {
+    get hasCustomConfigTaskList() {
+        return !!this.taskService.getConfigCustomTaskList();
+    }
+    get fields$() {
+        return this._fields$.asObservable();
+    }
+    get taskListColumnsForCase$() {
+        return this.taskListService.caseDefinitionName$.pipe(tap(caseDefinitionName => {
+            if (caseDefinitionName === this.taskListService.ALL_CASES_ID) {
+                this.resetTaskListFields();
+            }
+        }), filter(caseDefinitionName => !!caseDefinitionName && caseDefinitionName !== this.taskListService.ALL_CASES_ID), switchMap(caseDefinitionName => this.taskService.getTaskListColumns(caseDefinitionName)), tap(taskListColumns => {
+            if (taskListColumns.length === 0) {
+                this.taskListSortService.updateSortStates({
+                    isSorting: true,
+                    state: {
+                        name: this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS[0].key,
+                        direction: 'DESC',
+                    },
+                });
+                this._fields$.next(this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS);
+            }
+            else {
+                this._fields$.next(this.mapTaskListColumnToColumnConfig(taskListColumns));
+            }
+        }), tap(() => this.taskListService.setLoadingStateForCaseDefinition(false)));
+    }
+    constructor(taskService, taskListService, taskListSortService) {
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        this.taskListSortService = taskListSortService;
+        this._DEFAULT_TASK_LIST_FIELDS = [
+            {
+                key: 'created',
+                label: `task-list.fieldLabels.created`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'name',
+                label: `task-list.fieldLabels.name`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'valtimoAssignee.fullName',
+                label: `task-list.fieldLabels.valtimoAssignee.fullName`,
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'due',
+                label: `task-list.fieldLabels.due`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'context',
+                label: `task-list.fieldLabels.context`,
+                viewType: ViewType.TEXT,
+            },
+        ];
+        this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS = [
+            {
+                key: 'createTime',
+                label: `task-list.fieldLabels.created`,
+                viewType: ViewType.DATE,
+                sortable: true,
+                format: 'DD MMM YYYY HH:mm',
+            },
+            {
+                key: 'name',
+                label: `task-list.fieldLabels.name`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'assignee',
+                label: `task-list.fieldLabels.valtimoAssignee.fullName`,
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'dueDate',
+                label: `task-list.fieldLabels.due`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+        ];
+        this._fields$ = new BehaviorSubject(this._DEFAULT_TASK_LIST_FIELDS);
+    }
+    resetTaskListFields() {
+        if (this.hasCustomConfigTaskList) {
+            this.setFieldsToCustomTaskListFields();
+        }
+        else {
+            this.setFieldsToDefaultTaskListFields();
+        }
+        this.taskListSortService.resetDefaultSortStates();
+        this.taskListService.setLoadingStateForCaseDefinition(false);
+    }
+    setFieldsToCustomTaskListFields() {
+        const customTaskListFields = this.taskService.getConfigCustomTaskList().fields;
+        if (customTaskListFields) {
+            this._fields$.next(customTaskListFields.map((column, index) => ({
+                key: column.propertyName,
+                label: `task-list.fieldLabels.${column.translationKey}`,
+                sortable: column.sortable,
+                ...(column.viewType && { viewType: column.viewType }),
+                ...(column.enum && { enum: column.enum }),
+            })));
+        }
+    }
+    setFieldsToDefaultTaskListFields() {
+        this._fields$.next(this._DEFAULT_TASK_LIST_FIELDS);
+    }
+    mapTaskListColumnToColumnConfig(taskListColumns) {
+        const hasDefaultSort = !!taskListColumns.find(column => column.defaultSort);
+        const firstSortableColumn = taskListColumns.find(column => column.sortable);
+        if (!hasDefaultSort && firstSortableColumn) {
+            this.taskListSortService.updateSortStates({
+                isSorting: true,
+                state: {
+                    name: firstSortableColumn.key,
+                    direction: 'DESC',
+                },
+            });
+        }
+        if (!hasDefaultSort && !firstSortableColumn) {
+            this.taskListSortService.clearSortStates();
+        }
+        return taskListColumns.map(column => {
+            if (column.defaultSort) {
+                this.taskListSortService.updateSortStates({
+                    isSorting: true,
+                    state: {
+                        name: column.key,
+                        direction: column.defaultSort,
+                    },
+                });
+            }
+            return {
+                viewType: this.getViewType(column.displayType.type),
+                key: column.key,
+                label: column.title || column.key,
+                sortable: column.sortable,
+                ...(column?.displayType?.displayTypeParameters?.enum && {
+                    enum: column?.displayType?.displayTypeParameters?.enum,
+                }),
+                ...(column?.displayType?.displayTypeParameters?.dateFormat && {
+                    format: column?.displayType?.displayTypeParameters?.dateFormat,
+                }),
+            };
+        });
+    }
+    getViewType(taskListColumnColumnDisplayType) {
+        switch (taskListColumnColumnDisplayType) {
+            case 'arrayCount':
+                return 'relatedFiles';
+            case 'underscoresToSpaces':
+                return 'stringReplaceUnderscore';
+            default:
+                return taskListColumnColumnDisplayType;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListColumnService, deps: [{ token: i1.TaskService }, { token: i2.TaskListService }, { token: i3.TaskListSortService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListColumnService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListColumnService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TaskService }, { type: i2.TaskListService }, { type: i3.TaskListSortService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-list-column.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/task/src/lib/services/task-list-column.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAe,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAC,eAAe,EAAE,MAAM,EAAc,SAAS,EAAE,GAAG,EAAC,MAAM,MAAM,CAAC;;;;;AAOzE,MAAM,OAAO,qBAAqB;IA6DhC,IAAY,uBAAuB;QACjC,OAAO,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,CAAC;IACtD,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;IACtC,CAAC;IAED,IAAW,uBAAuB;QAChC,OAAO,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,IAAI,CAClD,GAAG,CAAC,kBAAkB,CAAC,EAAE;YACvB,IAAI,kBAAkB,KAAK,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;gBAC7D,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,CAAC;QACH,CAAC,CAAC,EACF,MAAM,CACJ,kBAAkB,CAAC,EAAE,CACnB,CAAC,CAAC,kBAAkB,IAAI,kBAAkB,KAAK,IAAI,CAAC,eAAe,CAAC,YAAY,CACnF,EACD,SAAS,CAAC,kBAAkB,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,EACxF,GAAG,CAAC,eAAe,CAAC,EAAE;YACpB,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjC,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;oBACxC,SAAS,EAAE,IAAI;oBACf,KAAK,EAAE;wBACL,IAAI,EAAE,IAAI,CAAC,mCAAmC,CAAC,CAAC,CAAC,CAAC,GAAG;wBACrD,SAAS,EAAE,MAAM;qBAClB;iBACF,CAAC,CAAC;gBACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;YAC/D,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,+BAA+B,CAAC,eAAe,CAAC,CAAC,CAAC;YAC5E,CAAC;QACH,CAAC,CAAC,EACF,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC,CACxE,CAAC;IACJ,CAAC;IAED,YACmB,WAAwB,EACxB,eAAgC,EAChC,mBAAwC;QAFxC,gBAAW,GAAX,WAAW,CAAa;QACxB,oBAAe,GAAf,eAAe,CAAiB;QAChC,wBAAmB,GAAnB,mBAAmB,CAAqB;QArG1C,8BAAyB,GAAmB;YAC3D;gBACE,GAAG,EAAE,SAAS;gBACd,KAAK,EAAE,+BAA+B;gBACtC,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,QAAQ,EAAE,IAAI;aACf;YACD;gBACE,GAAG,EAAE,MAAM;gBACX,KAAK,EAAE,4BAA4B;gBACnC,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,QAAQ,EAAE,IAAI;aACf;YACD;gBACE,GAAG,EAAE,0BAA0B;gBAC/B,KAAK,EAAE,gDAAgD;gBACvD,QAAQ,EAAE,QAAQ,CAAC,IAAI;aACxB;YACD;gBACE,GAAG,EAAE,KAAK;gBACV,KAAK,EAAE,2BAA2B;gBAClC,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,QAAQ,EAAE,IAAI;aACf;YACD;gBACE,GAAG,EAAE,SAAS;gBACd,KAAK,EAAE,+BAA+B;gBACtC,QAAQ,EAAE,QAAQ,CAAC,IAAI;aACxB;SACF,CAAC;QAEe,wCAAmC,GAAmB;YACrE;gBACE,GAAG,EAAE,YAAY;gBACjB,KAAK,EAAE,+BAA+B;gBACtC,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,QAAQ,EAAE,IAAI;gBACd,MAAM,EAAE,mBAAmB;aAC5B;YACD;gBACE,GAAG,EAAE,MAAM;gBACX,KAAK,EAAE,4BAA4B;gBACnC,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,QAAQ,EAAE,IAAI;aACf;YACD;gBACE,GAAG,EAAE,UAAU;gBACf,KAAK,EAAE,gDAAgD;gBACvD,QAAQ,EAAE,QAAQ,CAAC,IAAI;aACxB;YACD;gBACE,GAAG,EAAE,SAAS;gBACd,KAAK,EAAE,2BAA2B;gBAClC,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,QAAQ,EAAE,IAAI;aACf;SACF,CAAC;QAEe,aAAQ,GAAG,IAAI,eAAe,CAAiB,IAAI,CAAC,yBAAyB,CAAC,CAAC;IA4C7F,CAAC;IAEG,mBAAmB;QACxB,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACjC,IAAI,CAAC,+BAA+B,EAAE,CAAC;QACzC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,gCAAgC,EAAE,CAAC;QAC1C,CAAC;QAED,IAAI,CAAC,mBAAmB,CAAC,sBAAsB,EAAE,CAAC;QAClD,IAAI,CAAC,eAAe,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,+BAA+B;QACrC,MAAM,oBAAoB,GAAG,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,CAAC,MAAM,CAAC;QAE/E,IAAI,oBAAoB,EAAE,CAAC;YACzB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,oBAAoB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;gBAC3C,GAAG,EAAE,MAAM,CAAC,YAAY;gBACxB,KAAK,EAAE,yBAAyB,MAAM,CAAC,cAAc,EAAE;gBACvD,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAC,CAAC;gBACnD,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,EAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAC,CAAC;aACxC,CAAC,CAAC,CACJ,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,gCAAgC;QACtC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IACrD,CAAC;IAEO,+BAA+B,CACrC,eAAsC;QAEtC,MAAM,cAAc,GAAG,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC5E,MAAM,mBAAmB,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE5E,IAAI,CAAC,cAAc,IAAI,mBAAmB,EAAE,CAAC;YAC3C,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;gBACxC,SAAS,EAAE,IAAI;gBACf,KAAK,EAAE;oBACL,IAAI,EAAE,mBAAmB,CAAC,GAAG;oBAC7B,SAAS,EAAE,MAAM;iBAClB;aACF,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,cAAc,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC5C,IAAI,CAAC,mBAAmB,CAAC,eAAe,EAAE,CAAC;QAC7C,CAAC;QAED,OAAO,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YAClC,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;gBACvB,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;oBACxC,SAAS,EAAE,IAAI;oBACf,KAAK,EAAE;wBACL,IAAI,EAAE,MAAM,CAAC,GAAG;wBAChB,SAAS,EAAE,MAAM,CAAC,WAAW;qBAC9B;iBACF,CAAC,CAAC;YACL,CAAC;YAED,OAAO;gBACL,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC;gBACnD,GAAG,EAAE,MAAM,CAAC,GAAG;gBACf,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,GAAG;gBACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,qBAAqB,EAAE,IAAI,IAAI;oBACtD,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,qBAAqB,EAAE,IAAI;iBACvD,CAAC;gBACF,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,qBAAqB,EAAE,UAAU,IAAI;oBAC5D,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,qBAAqB,EAAE,UAAU;iBAC/D,CAAC;aACH,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,WAAW,CAAC,+BAAuC;QACzD,QAAQ,+BAA+B,EAAE,CAAC;YACxC,KAAK,YAAY;gBACf,OAAO,cAAc,CAAC;YACxB,KAAK,qBAAqB;gBACxB,OAAO,yBAAyB,CAAC;YACnC;gBACE,OAAO,+BAA+B,CAAC;QAC3C,CAAC;IACH,CAAC;8GA/LU,qBAAqB;kHAArB,qBAAqB;;2FAArB,qBAAqB;kBADjC,UAAU","sourcesContent":["/*\n * Copyright 2015-2024 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 {ColumnConfig, ViewType} from '@valtimo/components';\nimport {BehaviorSubject, filter, Observable, switchMap, tap} from 'rxjs';\nimport {TaskService} from './task.service';\nimport {TaskListColumn} from '../models';\nimport {TaskListService} from './task-list.service';\nimport {TaskListSortService} from './task-list-sort.service';\n\n@Injectable()\nexport class TaskListColumnService {\n  private readonly _DEFAULT_TASK_LIST_FIELDS: ColumnConfig[] = [\n    {\n      key: 'created',\n      label: `task-list.fieldLabels.created`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'name',\n      label: `task-list.fieldLabels.name`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'valtimoAssignee.fullName',\n      label: `task-list.fieldLabels.valtimoAssignee.fullName`,\n      viewType: ViewType.TEXT,\n    },\n    {\n      key: 'due',\n      label: `task-list.fieldLabels.due`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'context',\n      label: `task-list.fieldLabels.context`,\n      viewType: ViewType.TEXT,\n    },\n  ];\n\n  private readonly _DEFAULT_SPECIFIED_TASK_LIST_FIELDS: ColumnConfig[] = [\n    {\n      key: 'createTime',\n      label: `task-list.fieldLabels.created`,\n      viewType: ViewType.DATE,\n      sortable: true,\n      format: 'DD MMM YYYY HH:mm',\n    },\n    {\n      key: 'name',\n      label: `task-list.fieldLabels.name`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'assignee',\n      label: `task-list.fieldLabels.valtimoAssignee.fullName`,\n      viewType: ViewType.TEXT,\n    },\n    {\n      key: 'dueDate',\n      label: `task-list.fieldLabels.due`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n  ];\n\n  private readonly _fields$ = new BehaviorSubject<ColumnConfig[]>(this._DEFAULT_TASK_LIST_FIELDS);\n\n  private get hasCustomConfigTaskList(): boolean {\n    return !!this.taskService.getConfigCustomTaskList();\n  }\n\n  public get fields$(): Observable<ColumnConfig[]> {\n    return this._fields$.asObservable();\n  }\n\n  public get taskListColumnsForCase$(): Observable<TaskListColumn[]> {\n    return this.taskListService.caseDefinitionName$.pipe(\n      tap(caseDefinitionName => {\n        if (caseDefinitionName === this.taskListService.ALL_CASES_ID) {\n          this.resetTaskListFields();\n        }\n      }),\n      filter(\n        caseDefinitionName =>\n          !!caseDefinitionName && caseDefinitionName !== this.taskListService.ALL_CASES_ID\n      ),\n      switchMap(caseDefinitionName => this.taskService.getTaskListColumns(caseDefinitionName)),\n      tap(taskListColumns => {\n        if (taskListColumns.length === 0) {\n          this.taskListSortService.updateSortStates({\n            isSorting: true,\n            state: {\n              name: this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS[0].key,\n              direction: 'DESC',\n            },\n          });\n          this._fields$.next(this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS);\n        } else {\n          this._fields$.next(this.mapTaskListColumnToColumnConfig(taskListColumns));\n        }\n      }),\n      tap(() => this.taskListService.setLoadingStateForCaseDefinition(false))\n    );\n  }\n\n  constructor(\n    private readonly taskService: TaskService,\n    private readonly taskListService: TaskListService,\n    private readonly taskListSortService: TaskListSortService\n  ) {}\n\n  public resetTaskListFields(): void {\n    if (this.hasCustomConfigTaskList) {\n      this.setFieldsToCustomTaskListFields();\n    } else {\n      this.setFieldsToDefaultTaskListFields();\n    }\n\n    this.taskListSortService.resetDefaultSortStates();\n    this.taskListService.setLoadingStateForCaseDefinition(false);\n  }\n\n  private setFieldsToCustomTaskListFields(): void {\n    const customTaskListFields = this.taskService.getConfigCustomTaskList().fields;\n\n    if (customTaskListFields) {\n      this._fields$.next(\n        customTaskListFields.map((column, index) => ({\n          key: column.propertyName,\n          label: `task-list.fieldLabels.${column.translationKey}`,\n          sortable: column.sortable,\n          ...(column.viewType && {viewType: column.viewType}),\n          ...(column.enum && {enum: column.enum}),\n        }))\n      );\n    }\n  }\n\n  private setFieldsToDefaultTaskListFields(): void {\n    this._fields$.next(this._DEFAULT_TASK_LIST_FIELDS);\n  }\n\n  private mapTaskListColumnToColumnConfig(\n    taskListColumns: Array<TaskListColumn>\n  ): Array<ColumnConfig> {\n    const hasDefaultSort = !!taskListColumns.find(column => column.defaultSort);\n    const firstSortableColumn = taskListColumns.find(column => column.sortable);\n\n    if (!hasDefaultSort && firstSortableColumn) {\n      this.taskListSortService.updateSortStates({\n        isSorting: true,\n        state: {\n          name: firstSortableColumn.key,\n          direction: 'DESC',\n        },\n      });\n    }\n\n    if (!hasDefaultSort && !firstSortableColumn) {\n      this.taskListSortService.clearSortStates();\n    }\n\n    return taskListColumns.map(column => {\n      if (column.defaultSort) {\n        this.taskListSortService.updateSortStates({\n          isSorting: true,\n          state: {\n            name: column.key,\n            direction: column.defaultSort,\n          },\n        });\n      }\n\n      return {\n        viewType: this.getViewType(column.displayType.type),\n        key: column.key,\n        label: column.title || column.key,\n        sortable: column.sortable,\n        ...(column?.displayType?.displayTypeParameters?.enum && {\n          enum: column?.displayType?.displayTypeParameters?.enum,\n        }),\n        ...(column?.displayType?.displayTypeParameters?.dateFormat && {\n          format: column?.displayType?.displayTypeParameters?.dateFormat,\n        }),\n      };\n    });\n  }\n\n  private getViewType(taskListColumnColumnDisplayType: string): string {\n    switch (taskListColumnColumnDisplayType) {\n      case 'arrayCount':\n        return 'relatedFiles';\n      case 'underscoresToSpaces':\n        return 'stringReplaceUnderscore';\n      default:\n        return taskListColumnColumnDisplayType;\n    }\n  }\n}\n"]}

package/esm2022/lib/services/task-list-pagination.service.mjs

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2015-2024 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, combineLatest } from 'rxjs';
+import { TaskListTab } from '@valtimo/config';
+import { map, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./task-list.service";
+export class TaskListPaginationService {
+    get paginationForCurrentTaskType$() {
+        return this._paginationForCurrentTaskType$;
+    }
+    get paginationForCurrentTaskTypeForList$() {
+        return this._paginationForCurrentTaskType$.pipe(map(pagination => ({ ...pagination, page: pagination?.page + 1 || 1 })));
+    }
+    constructor(taskListService) {
+        this.taskListService = taskListService;
+        this._pagination$ = new BehaviorSubject({
+            [TaskListTab.ALL]: this.getDefaultPagination(),
+            [TaskListTab.MINE]: this.getDefaultPagination(),
+            [TaskListTab.OPEN]: this.getDefaultPagination(),
+        });
+        this._paginationForCurrentTaskType$ = combineLatest([
+            this.taskListService.selectedTaskType$,
+            this._pagination$,
+        ]).pipe(map(([selectedTaskType, pagination]) => pagination[selectedTaskType]));
+    }
+    updateTaskPagination(taskType, updatedPagination) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            const currentPagination = pagination[taskType];
+            this._pagination$.next({
+                ...pagination,
+                [taskType]: { ...currentPagination, ...updatedPagination },
+            });
+        });
+    }
+    getLastAvailablePage(page, size, collectionSize) {
+        if (this.isNumber(page) && this.isNumber(size) && this.isNumber(collectionSize) && page !== 0) {
+            const amountOfPages = Math.ceil(collectionSize / size);
+            if (page + 1 > amountOfPages) {
+                return amountOfPages - 1;
+            }
+        }
+        return page;
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    getDefaultPagination() {
+        return {
+            page: 0,
+            size: 10,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListPaginationService, deps: [{ token: i1.TaskListService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListPaginationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListPaginationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TaskListService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/task-list-query-param.service.mjs

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2015-2024 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 { omit } from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class TaskListQueryParamService {
+    setTaskListParams(params) {
+        const queryParams = omit(params, 'reload');
+        const encodedQueryParams = Object.keys(queryParams).reduce((acc, curr) => ({ ...acc, [curr]: this.objectToBase64(queryParams[curr]) }), {});
+        this.router.navigate([this.getUrlWithoutParams()], { queryParams: encodedQueryParams });
+    }
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+    }
+    getTaskListQueryParams() {
+        const queryParams = this.route.snapshot.queryParams;
+        const decodedParams = Object.keys(queryParams).reduce((acc, curr) => ({ ...acc, [curr]: this.parseBase64(queryParams[curr]) }), {});
+        return decodedParams;
+    }
+    getUrlWithoutParams() {
+        const urlTree = this.router.parseUrl(this.router.url);
+        urlTree.queryParams = {};
+        urlTree.fragment = null;
+        return urlTree.toString();
+    }
+    objectToBase64(jsObject) {
+        return btoa(JSON.stringify(jsObject));
+    }
+    parseBase64(base64string) {
+        return JSON.parse(atob(base64string));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListQueryParamService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListQueryParamService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListQueryParamService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i1.ActivatedRoute }] });
+//# sourceMappingURL=data:application/json;base64,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