@alfresco/adf-process-services-cloud 8.1.0-15113180840 → 8.1.0-15139516875

package/esm2022/lib/task/task-list/components/base-task-list-cloud.component.mjs

@@ -0,0 +1,331 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { ContentChild, DestroyRef, Directive, EventEmitter, inject, Input, Output } from '@angular/core';
+import { AppConfigService, CustomEmptyContentTemplateDirective, DataTableSchema, UserPreferencesService, UserPreferenceValues } from '@alfresco/adf-core';
+import { BehaviorSubject } from 'rxjs';
+import { TaskListCloudSortingModel } from '../../../models/task-list-sorting.model';
+import { map, take } from 'rxjs/operators';
+import { TaskCloudService } from '../../services/task-cloud.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../services/task-cloud.service";
+// eslint-disable-next-line no-shadow
+export var TasksListCloudPreferences;
+(function (TasksListCloudPreferences) {
+    TasksListCloudPreferences["columnOrder"] = "tasks-list-cloud-columns-order";
+    TasksListCloudPreferences["columnsVisibility"] = "tasks-list-cloud-columns-visibility";
+    TasksListCloudPreferences["columnsWidths"] = "tasks-list-cloud-columns-widths";
+})(TasksListCloudPreferences || (TasksListCloudPreferences = {}));
+const taskPresetsCloudDefaultModel = {
+    default: [
+        {
+            id: 'name',
+            key: 'name',
+            type: 'text',
+            title: 'ADF_CLOUD_TASK_LIST.PROPERTIES.NAME',
+            sortable: true
+        },
+        {
+            id: 'created',
+            key: 'created',
+            type: 'text',
+            title: 'ADF_CLOUD_TASK_LIST.PROPERTIES.CREATED',
+            cssClass: 'hidden',
+            sortable: true
+        },
+        {
+            id: 'assignee',
+            key: 'assignee',
+            type: 'text',
+            title: 'ADF_CLOUD_TASK_LIST.PROPERTIES.ASSIGNEE',
+            cssClass: 'hidden',
+            sortable: true
+        }
+    ]
+};
+/* eslint-disable @typescript-eslint/brace-style */
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class BaseTaskListCloudComponent extends DataTableSchema {
+    constructor(appConfigService, taskCloudService, userPreferences, presetKey, cloudPreferenceService) {
+        super(appConfigService, presetKey, taskPresetsCloudDefaultModel);
+        this.taskCloudService = taskCloudService;
+        this.userPreferences = userPreferences;
+        this.cloudPreferenceService = cloudPreferenceService;
+        /** The name of the application. */
+        this.appName = '';
+        /**
+         * Row selection mode. Can be none, `single` or `multiple`. For `multiple` mode,
+         * you can use the Cmd (macOS) or Ctrl (Win) modifier key to toggle selection for
+         * multiple rows.
+         */
+        this.selectionMode = 'single'; // none|single|multiple
+        /** Toggles multiple row selection, rendering a checkbox at the beginning of each row. */
+        this.multiselect = false;
+        /** Toggles the sticky header mode. */
+        this.stickyHeader = false;
+        /** Toggles the data actions column. */
+        this.showActions = false;
+        /** Position of the actions dropdown menu. Can be "left" or "right". */
+        this.actionsPosition = 'right'; // left|right
+        /** Toggles custom context menu for the component. */
+        this.showContextMenu = false;
+        /** Toggles the provided actions. */
+        this.showProvidedActions = false;
+        /** Toggles main datatable actions. */
+        this.showMainDatatableActions = false;
+        /** Toggles main datatable column resizing feature. */
+        this.isResizingEnabled = false;
+        /** Emitted before the context menu is displayed for a row. */
+        this.showRowContextMenu = new EventEmitter();
+        /** Emitted before the actions menu is displayed for a row. */
+        this.showRowActionsMenu = new EventEmitter();
+        /** Emitted when the user executes a row action. */
+        this.executeRowAction = new EventEmitter();
+        /** Emitted when a task in the list is clicked */
+        this.rowClick = new EventEmitter();
+        /** Emitted when rows are selected/unselected */
+        this.rowsSelected = new EventEmitter();
+        /** Emitted when the task list is loaded */
+        this.success = new EventEmitter();
+        /** Emitted when an error occurs. */
+        this.error = new EventEmitter();
+        this.rows = [];
+        this.skipCount = 0;
+        this.defaultSorting = { key: 'startDate', direction: 'desc' };
+        this.isLoadingPreferences$ = new BehaviorSubject(true);
+        this.destroyRef = inject(DestroyRef);
+        this.size = userPreferences.paginationSize;
+        this.pagination = new BehaviorSubject({
+            maxItems: this.size,
+            skipCount: 0,
+            totalItems: 0
+        });
+        this.boundReplacePriorityValues = this.replacePriorityValues.bind(this);
+    }
+    ngOnInit() {
+        this.userPreferences
+            .select(UserPreferenceValues.PaginationSize)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((pageSize) => (this.size = pageSize));
+    }
+    ngOnChanges(changes) {
+        if (changes['sorting']) {
+            this.formatSorting(changes['sorting'].currentValue);
+        }
+        if (changes['appName']) {
+            this.retrieveTasksPreferences();
+        }
+        this.reload();
+    }
+    retrieveTasksPreferences() {
+        this.isLoadingPreferences$.next(true);
+        this.cloudPreferenceService
+            .getPreferences(this.appName)
+            .pipe(take(1), map((preferences) => {
+            const preferencesList = preferences?.list?.entries ?? [];
+            const columnsOrder = preferencesList.find((preference) => preference.entry.key === TasksListCloudPreferences.columnOrder);
+            const columnsVisibility = preferencesList.find((preference) => preference.entry.key === TasksListCloudPreferences.columnsVisibility);
+            const columnsWidths = preferencesList.find((preference) => preference.entry.key === TasksListCloudPreferences.columnsWidths);
+            return {
+                columnsOrder: columnsOrder ? JSON.parse(columnsOrder.entry.value) : undefined,
+                columnsVisibility: columnsVisibility ? JSON.parse(columnsVisibility.entry.value) : undefined,
+                columnsWidths: columnsWidths ? JSON.parse(columnsWidths.entry.value) : undefined
+            };
+        }))
+            .subscribe(({ columnsOrder, columnsVisibility, columnsWidths }) => {
+            if (columnsOrder) {
+                this.columnsOrder = columnsOrder;
+            }
+            if (columnsVisibility) {
+                this.columnsVisibility = columnsVisibility;
+            }
+            if (columnsWidths) {
+                this.columnsWidths = columnsWidths;
+            }
+            this.createDatatableSchema();
+            this.createColumns();
+            this.isLoadingPreferences$.next(false);
+        }, (error) => {
+            this.error.emit(error);
+            this.isLoadingPreferences$.next(false);
+        });
+    }
+    ngAfterContentInit() {
+        this.retrieveTasksPreferences();
+    }
+    isListEmpty() {
+        return !this.rows || this.rows.length === 0;
+    }
+    /**
+     * Resets the pagination values
+     */
+    resetPagination() {
+        this.skipCount = 0;
+        this.size = this.userPreferences.paginationSize;
+        this.pagination.next({
+            skipCount: 0,
+            maxItems: this.size
+        });
+    }
+    /**
+     * Resets the pagination values and
+     * Reloads the task list
+     *
+     * @param pagination Pagination values to be set
+     */
+    updatePagination(pagination) {
+        this.size = pagination.maxItems;
+        this.skipCount = pagination.skipCount;
+        this.pagination.next(pagination);
+        this.reload();
+    }
+    onSortingChanged(event) {
+        this.setSorting(event.detail);
+        this.formatSorting(this.sorting);
+        this.reload();
+    }
+    onRowClick(item) {
+        this.currentInstanceId = item.value.getValue('id');
+        this.rowClick.emit(this.currentInstanceId);
+    }
+    onRowSelect(event) {
+        this.selectedInstances = [...event.detail.selection];
+        this.rowsSelected.emit(this.selectedInstances);
+    }
+    onRowUnselect(event) {
+        this.selectedInstances = [...event.detail.selection];
+        this.rowsSelected.emit(this.selectedInstances);
+    }
+    onRowKeyUp(event) {
+        if (event.detail.keyboardEvent.key === 'Enter') {
+            event.preventDefault();
+            this.currentInstanceId = event.detail.row.getValue('id');
+            this.rowClick.emit(this.currentInstanceId);
+        }
+    }
+    onShowRowActionsMenu(event) {
+        this.showRowActionsMenu.emit(event);
+    }
+    onShowRowContextMenu(event) {
+        this.showRowContextMenu.emit(event);
+    }
+    onExecuteRowAction(row) {
+        this.executeRowAction.emit(row);
+    }
+    onColumnOrderChanged(columnsWithNewOrder) {
+        this.columnsOrder = columnsWithNewOrder.map((column) => column.id);
+        this.createColumns();
+        if (this.appName) {
+            this.cloudPreferenceService.updatePreference(this.appName, TasksListCloudPreferences.columnOrder, this.columnsOrder);
+        }
+    }
+    onColumnsVisibilityChange(columns) {
+        this.columnsVisibility = columns.reduce((visibleColumnsMap, column) => {
+            if (column.isHidden !== undefined) {
+                visibleColumnsMap[column.id] = !column.isHidden;
+            }
+            return visibleColumnsMap;
+        }, {});
+        this.createColumns();
+        this.createDatatableSchema();
+        if (this.appName) {
+            this.cloudPreferenceService.updatePreference(this.appName, TasksListCloudPreferences.columnsVisibility, this.columnsVisibility);
+        }
+    }
+    onColumnsWidthChanged(columns) {
+        const newColumnsWidths = columns.reduce((widthsColumnsMap, column) => {
+            if (column.width) {
+                widthsColumnsMap[column.id] = Math.ceil(column.width);
+            }
+            return widthsColumnsMap;
+        }, {});
+        this.columnsWidths = { ...this.columnsWidths, ...newColumnsWidths };
+        this.createColumns();
+        if (this.appName) {
+            this.cloudPreferenceService.updatePreference(this.appName, TasksListCloudPreferences.columnsWidths, this.columnsWidths);
+        }
+    }
+    setSorting(sortDetail) {
+        const sorting = sortDetail
+            ? {
+                orderBy: sortDetail.sortingKey || sortDetail.key,
+                direction: sortDetail.direction.toUpperCase()
+            }
+            : { ...this.defaultSorting };
+        this.sorting = [new TaskListCloudSortingModel(sorting)];
+    }
+    formatSorting(sorting) {
+        this.formattedSorting = this.isValidSorting(sorting) ? [sorting[0].orderBy, sorting[0].direction.toLocaleLowerCase()] : null;
+    }
+    isValidSorting(sorting) {
+        return sorting?.length && sorting[0].orderBy && sorting[0].direction;
+    }
+    replacePriorityValues(row, column) {
+        return column.key.split('.').reduce((source, key) => {
+            if (key === 'priority' && source && typeof source[key] === 'number') {
+                return (source[key] = this.taskCloudService.getPriorityLabel(source[key]));
+            }
+            return source && typeof source === 'object' ? source[key] : undefined;
+        }, row.obj);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseTaskListCloudComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: BaseTaskListCloudComponent, inputs: { appName: "appName", selectionMode: "selectionMode", multiselect: "multiselect", stickyHeader: "stickyHeader", sorting: "sorting", showActions: "showActions", actionsPosition: "actionsPosition", showContextMenu: "showContextMenu", showProvidedActions: "showProvidedActions", showMainDatatableActions: "showMainDatatableActions", isResizingEnabled: "isResizingEnabled" }, outputs: { showRowContextMenu: "showRowContextMenu", showRowActionsMenu: "showRowActionsMenu", executeRowAction: "executeRowAction", rowClick: "rowClick", rowsSelected: "rowsSelected", success: "success", error: "error" }, queries: [{ propertyName: "emptyCustomContent", first: true, predicate: CustomEmptyContentTemplateDirective, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseTaskListCloudComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.TaskCloudService }, { type: i1.UserPreferencesService }, { type: undefined }, { type: undefined }], propDecorators: { emptyCustomContent: [{
+                type: ContentChild,
+                args: [CustomEmptyContentTemplateDirective]
+            }], appName: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], multiselect: [{
+                type: Input
+            }], stickyHeader: [{
+                type: Input
+            }], sorting: [{
+                type: Input
+            }], showActions: [{
+                type: Input
+            }], actionsPosition: [{
+                type: Input
+            }], showContextMenu: [{
+                type: Input
+            }], showProvidedActions: [{
+                type: Input
+            }], showMainDatatableActions: [{
+                type: Input
+            }], isResizingEnabled: [{
+                type: Input
+            }], showRowContextMenu: [{
+                type: Output
+            }], showRowActionsMenu: [{
+                type: Output
+            }], executeRowAction: [{
+                type: Output
+            }], rowClick: [{
+                type: Output
+            }], rowsSelected: [{
+                type: Output
+            }], success: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-task-list-cloud.component.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/components/base-task-list-cloud.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (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 *     http://www.apache.org/licenses/LICENSE-2.0\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 {\n    AfterContentInit,\n    ContentChild,\n    DestroyRef,\n    Directive,\n    EventEmitter,\n    inject,\n    Input,\n    OnChanges,\n    OnInit,\n    Output,\n    SimpleChanges\n} from '@angular/core';\nimport {\n    AppConfigService,\n    CustomEmptyContentTemplateDirective,\n    DataCellEvent,\n    DataColumn,\n    DataRow,\n    DataRowActionEvent,\n    DataRowEvent,\n    DataTableSchema,\n    ObjectDataTableAdapter,\n    PaginatedComponent,\n    PaginationModel,\n    UserPreferencesService,\n    UserPreferenceValues\n} from '@alfresco/adf-core';\nimport { TaskQueryCloudRequestModel } from '../../../models/filter-cloud-model';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { TaskListCloudSortingModel } from '../../../models/task-list-sorting.model';\nimport { map, take } from 'rxjs/operators';\nimport { TaskCloudService } from '../../services/task-cloud.service';\nimport { PreferenceCloudServiceInterface } from '../../../services/preference-cloud.interface';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n// eslint-disable-next-line no-shadow\nexport enum TasksListCloudPreferences {\n    columnOrder = 'tasks-list-cloud-columns-order',\n    columnsVisibility = 'tasks-list-cloud-columns-visibility',\n    columnsWidths = 'tasks-list-cloud-columns-widths'\n}\n\nconst taskPresetsCloudDefaultModel = {\n    default: [\n        {\n            id: 'name',\n            key: 'name',\n            type: 'text',\n            title: 'ADF_CLOUD_TASK_LIST.PROPERTIES.NAME',\n            sortable: true\n        },\n        {\n            id: 'created',\n            key: 'created',\n            type: 'text',\n            title: 'ADF_CLOUD_TASK_LIST.PROPERTIES.CREATED',\n            cssClass: 'hidden',\n            sortable: true\n        },\n        {\n            id: 'assignee',\n            key: 'assignee',\n            type: 'text',\n            title: 'ADF_CLOUD_TASK_LIST.PROPERTIES.ASSIGNEE',\n            cssClass: 'hidden',\n            sortable: true\n        }\n    ]\n};\n\n/* eslint-disable @typescript-eslint/brace-style */\n\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class BaseTaskListCloudComponent<T = unknown>\n    extends DataTableSchema<T>\n    implements OnChanges, AfterContentInit, PaginatedComponent, OnInit\n{\n    @ContentChild(CustomEmptyContentTemplateDirective)\n    emptyCustomContent: CustomEmptyContentTemplateDirective;\n\n    /** The name of the application. */\n    @Input()\n    appName: string = '';\n\n    /**\n     * Row selection mode. Can be none, `single` or `multiple`. For `multiple` mode,\n     * you can use the Cmd (macOS) or Ctrl (Win) modifier key to toggle selection for\n     * multiple rows.\n     */\n    @Input()\n    selectionMode: string = 'single'; // none|single|multiple\n\n    /** Toggles multiple row selection, rendering a checkbox at the beginning of each row. */\n    @Input()\n    multiselect: boolean = false;\n\n    /** Toggles the sticky header mode. */\n    @Input()\n    stickyHeader: boolean = false;\n\n    /**\n     * Specifies how the table should be sorted. The parameters are for BE sorting.\n     */\n    @Input()\n    sorting: TaskListCloudSortingModel[];\n\n    /** Toggles the data actions column. */\n    @Input()\n    showActions: boolean = false;\n\n    /** Position of the actions dropdown menu. Can be \"left\" or \"right\". */\n    @Input()\n    actionsPosition: string = 'right'; // left|right\n\n    /** Toggles custom context menu for the component. */\n    @Input()\n    showContextMenu: boolean = false;\n\n    /** Toggles the provided actions. */\n    @Input()\n    showProvidedActions: boolean = false;\n\n    /** Toggles main datatable actions. */\n    @Input()\n    showMainDatatableActions: boolean = false;\n\n    /** Toggles main datatable column resizing feature. */\n    @Input()\n    isResizingEnabled: boolean = false;\n\n    /** Emitted before the context menu is displayed for a row. */\n    @Output()\n    showRowContextMenu = new EventEmitter<DataCellEvent>();\n\n    /** Emitted before the actions menu is displayed for a row. */\n    @Output()\n    showRowActionsMenu = new EventEmitter<DataCellEvent>();\n\n    /** Emitted when the user executes a row action. */\n    @Output()\n    executeRowAction = new EventEmitter<DataRowActionEvent>();\n\n    /** Emitted when a task in the list is clicked */\n    @Output()\n    rowClick: EventEmitter<string> = new EventEmitter<string>();\n\n    /** Emitted when rows are selected/unselected */\n    @Output()\n    rowsSelected: EventEmitter<unknown[]> = new EventEmitter<unknown[]>();\n\n    /** Emitted when the task list is loaded */\n    @Output()\n    success: EventEmitter<unknown> = new EventEmitter<unknown>();\n\n    /** Emitted when an error occurs. */\n    @Output()\n    error: EventEmitter<unknown> = new EventEmitter<unknown>();\n\n    pagination: BehaviorSubject<PaginationModel>;\n\n    requestNode: TaskQueryCloudRequestModel;\n    rows = [];\n    size: number;\n    skipCount: number = 0;\n    currentInstanceId: string;\n    selectedInstances: string[];\n    formattedSorting: string[];\n    dataAdapter: ObjectDataTableAdapter | undefined;\n\n    protected defaultSorting = { key: 'startDate', direction: 'desc' };\n    boundReplacePriorityValues: (row: DataRow, col: DataColumn) => unknown;\n\n    protected abstract isLoading$: Observable<boolean>;\n    protected isLoadingPreferences$ = new BehaviorSubject<boolean>(true);\n\n    protected readonly destroyRef = inject(DestroyRef);\n\n    constructor(\n        appConfigService: AppConfigService,\n        private taskCloudService: TaskCloudService,\n        private userPreferences: UserPreferencesService,\n        presetKey: string,\n        private cloudPreferenceService: PreferenceCloudServiceInterface\n    ) {\n        super(appConfigService, presetKey, taskPresetsCloudDefaultModel);\n        this.size = userPreferences.paginationSize;\n\n        this.pagination = new BehaviorSubject<PaginationModel>({\n            maxItems: this.size,\n            skipCount: 0,\n            totalItems: 0\n        });\n\n        this.boundReplacePriorityValues = this.replacePriorityValues.bind(this);\n    }\n\n    ngOnInit() {\n        this.userPreferences\n            .select(UserPreferenceValues.PaginationSize)\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe((pageSize) => (this.size = pageSize));\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['sorting']) {\n            this.formatSorting(changes['sorting'].currentValue);\n        }\n        if (changes['appName']) {\n            this.retrieveTasksPreferences();\n        }\n        this.reload();\n    }\n\n    private retrieveTasksPreferences(): void {\n        this.isLoadingPreferences$.next(true);\n        this.cloudPreferenceService\n            .getPreferences(this.appName)\n            .pipe(\n                take(1),\n                map((preferences) => {\n                    const preferencesList = preferences?.list?.entries ?? [];\n                    const columnsOrder = preferencesList.find((preference) => preference.entry.key === TasksListCloudPreferences.columnOrder);\n                    const columnsVisibility = preferencesList.find(\n                        (preference) => preference.entry.key === TasksListCloudPreferences.columnsVisibility\n                    );\n                    const columnsWidths = preferencesList.find((preference) => preference.entry.key === TasksListCloudPreferences.columnsWidths);\n\n                    return {\n                        columnsOrder: columnsOrder ? JSON.parse(columnsOrder.entry.value) : undefined,\n                        columnsVisibility: columnsVisibility ? JSON.parse(columnsVisibility.entry.value) : undefined,\n                        columnsWidths: columnsWidths ? JSON.parse(columnsWidths.entry.value) : undefined\n                    };\n                })\n            )\n            .subscribe(\n                ({ columnsOrder, columnsVisibility, columnsWidths }) => {\n                    if (columnsOrder) {\n                        this.columnsOrder = columnsOrder;\n                    }\n\n                    if (columnsVisibility) {\n                        this.columnsVisibility = columnsVisibility;\n                    }\n\n                    if (columnsWidths) {\n                        this.columnsWidths = columnsWidths;\n                    }\n\n                    this.createDatatableSchema();\n                    this.createColumns();\n                    this.isLoadingPreferences$.next(false);\n                },\n                (error) => {\n                    this.error.emit(error);\n                    this.isLoadingPreferences$.next(false);\n                }\n            );\n    }\n\n    ngAfterContentInit(): void {\n        this.retrieveTasksPreferences();\n    }\n\n    isListEmpty(): boolean {\n        return !this.rows || this.rows.length === 0;\n    }\n\n    /**\n     * Resets the pagination values\n     */\n    resetPagination() {\n        this.skipCount = 0;\n        this.size = this.userPreferences.paginationSize;\n        this.pagination.next({\n            skipCount: 0,\n            maxItems: this.size\n        });\n    }\n\n    /**\n     * Resets the pagination values and\n     * Reloads the task list\n     *\n     * @param pagination Pagination values to be set\n     */\n    updatePagination(pagination: PaginationModel) {\n        this.size = pagination.maxItems;\n        this.skipCount = pagination.skipCount;\n        this.pagination.next(pagination);\n        this.reload();\n    }\n\n    onSortingChanged(event: CustomEvent) {\n        this.setSorting(event.detail);\n        this.formatSorting(this.sorting);\n        this.reload();\n    }\n\n    onRowClick(item: DataRowEvent) {\n        this.currentInstanceId = item.value.getValue('id');\n        this.rowClick.emit(this.currentInstanceId);\n    }\n\n    onRowSelect(event: CustomEvent) {\n        this.selectedInstances = [...event.detail.selection];\n        this.rowsSelected.emit(this.selectedInstances);\n    }\n\n    onRowUnselect(event: CustomEvent) {\n        this.selectedInstances = [...event.detail.selection];\n        this.rowsSelected.emit(this.selectedInstances);\n    }\n\n    onRowKeyUp(event: CustomEvent) {\n        if (event.detail.keyboardEvent.key === 'Enter') {\n            event.preventDefault();\n            this.currentInstanceId = event.detail.row.getValue('id');\n            this.rowClick.emit(this.currentInstanceId);\n        }\n    }\n\n    onShowRowActionsMenu(event: DataCellEvent) {\n        this.showRowActionsMenu.emit(event);\n    }\n\n    onShowRowContextMenu(event: DataCellEvent) {\n        this.showRowContextMenu.emit(event);\n    }\n\n    onExecuteRowAction(row: DataRowActionEvent) {\n        this.executeRowAction.emit(row);\n    }\n\n    onColumnOrderChanged(columnsWithNewOrder: DataColumn[]): void {\n        this.columnsOrder = columnsWithNewOrder.map((column) => column.id);\n        this.createColumns();\n\n        if (this.appName) {\n            this.cloudPreferenceService.updatePreference(this.appName, TasksListCloudPreferences.columnOrder, this.columnsOrder);\n        }\n    }\n\n    onColumnsVisibilityChange(columns: DataColumn[]): void {\n        this.columnsVisibility = columns.reduce((visibleColumnsMap, column) => {\n            if (column.isHidden !== undefined) {\n                visibleColumnsMap[column.id] = !column.isHidden;\n            }\n\n            return visibleColumnsMap;\n        }, {});\n\n        this.createColumns();\n        this.createDatatableSchema();\n\n        if (this.appName) {\n            this.cloudPreferenceService.updatePreference(this.appName, TasksListCloudPreferences.columnsVisibility, this.columnsVisibility);\n        }\n    }\n\n    onColumnsWidthChanged(columns: DataColumn[]): void {\n        const newColumnsWidths = columns.reduce((widthsColumnsMap, column) => {\n            if (column.width) {\n                widthsColumnsMap[column.id] = Math.ceil(column.width);\n            }\n            return widthsColumnsMap;\n        }, {});\n\n        this.columnsWidths = { ...this.columnsWidths, ...newColumnsWidths };\n\n        this.createColumns();\n\n        if (this.appName) {\n            this.cloudPreferenceService.updatePreference(this.appName, TasksListCloudPreferences.columnsWidths, this.columnsWidths);\n        }\n    }\n\n    setSorting(sortDetail) {\n        const sorting = sortDetail\n            ? {\n                  orderBy: sortDetail.sortingKey || sortDetail.key,\n                  direction: sortDetail.direction.toUpperCase()\n              }\n            : { ...this.defaultSorting };\n        this.sorting = [new TaskListCloudSortingModel(sorting)];\n    }\n\n    formatSorting(sorting: TaskListCloudSortingModel[]) {\n        this.formattedSorting = this.isValidSorting(sorting) ? [sorting[0].orderBy, sorting[0].direction.toLocaleLowerCase()] : null;\n    }\n\n    isValidSorting(sorting: TaskListCloudSortingModel[]) {\n        return sorting?.length && sorting[0].orderBy && sorting[0].direction;\n    }\n\n    replacePriorityValues(row: DataRow, column: DataColumn) {\n        return column.key.split('.').reduce((source, key) => {\n            if (key === 'priority' && source && typeof source[key] === 'number') {\n                return (source[key] = this.taskCloudService.getPriorityLabel(source[key]));\n            }\n            return source && typeof source === 'object' ? source[key] : undefined;\n        }, row.obj);\n    }\n\n    abstract reload();\n}\n"]}

package/esm2022/lib/task/task-list/components/service-task-list/service-task-list-cloud.component.mjs

@@ -0,0 +1,116 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { Component, Inject, Input, ViewEncapsulation } from '@angular/core';
+import { AppConfigService, ColumnsSelectorComponent, DataTableComponent, EmptyContentComponent, LoadingContentTemplateDirective, MainMenuDataTableTemplateDirective, NoContentTemplateDirective, UserPreferencesService } from '@alfresco/adf-core';
+import { BaseTaskListCloudComponent } from '../base-task-list-cloud.component';
+import { ServiceTaskListCloudService } from '../../services/service-task-list-cloud.service';
+import { TaskCloudService } from '../../../services/task-cloud.service';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { TASK_LIST_PREFERENCES_SERVICE_TOKEN } from '../../../../services/public-api';
+import { map } from 'rxjs/operators';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/service-task-list-cloud.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "../../../services/task-cloud.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/material/progress-spinner";
+const PRESET_KEY = 'adf-cloud-service-task-list.presets';
+export class ServiceTaskListCloudComponent extends BaseTaskListCloudComponent {
+    constructor(serviceTaskListCloudService, appConfigService, taskCloudService, userPreferences, cloudPreferenceService) {
+        super(appConfigService, taskCloudService, userPreferences, PRESET_KEY, cloudPreferenceService);
+        this.serviceTaskListCloudService = serviceTaskListCloudService;
+        this.queryParams = {};
+        this.isReloadingSubject$ = new BehaviorSubject(false);
+        this.isLoading$ = combineLatest([this.isLoadingPreferences$, this.isReloadingSubject$]).pipe(map(([isLoadingPreferences, isReloading]) => isLoadingPreferences || isReloading));
+    }
+    reload() {
+        this.isReloadingSubject$.next(true);
+        this.requestNode = this.createRequestNode();
+        if (this.requestNode.appName || this.requestNode.appName === '') {
+            combineLatest([this.serviceTaskListCloudService.getServiceTaskByRequest(this.requestNode), this.isColumnSchemaCreated$])
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe(([tasks]) => {
+                this.rows = tasks.list.entries.map((task) => task.entry);
+                this.success.emit(tasks);
+                this.pagination.next(tasks.list.pagination);
+                this.isReloadingSubject$.next(false);
+            }, (error) => {
+                this.error.emit(error);
+                this.isReloadingSubject$.next(false);
+            });
+        }
+        else {
+            this.rows = [];
+        }
+    }
+    createRequestNode() {
+        const requestNode = {
+            appName: this.appName,
+            maxItems: this.size,
+            skipCount: this.skipCount,
+            sorting: this.sorting,
+            id: this.queryParams?.serviceTaskId,
+            environmentId: this.queryParams?.environmentId,
+            activityName: this.queryParams?.activityName,
+            activityType: this.queryParams?.activityType,
+            completedDate: this.queryParams?.completedDate,
+            completedFrom: this.queryParams?.completedFrom,
+            completedTo: this.queryParams?.completedTo,
+            elementId: this.queryParams?.elementId,
+            executionId: this.queryParams?.executionId,
+            processDefinitionId: this.queryParams?.processDefinitionId,
+            processDefinitionKey: this.queryParams?.processDefinitionKey,
+            processDefinitionVersion: this.queryParams?.processDefinitionVersion,
+            processInstanceId: this.queryParams?.processInstanceId,
+            serviceFullName: this.queryParams?.serviceFullName,
+            serviceName: this.queryParams?.serviceName,
+            serviceVersion: this.queryParams?.serviceVersion,
+            startedDate: this.queryParams?.startedDate,
+            startedFrom: this.queryParams?.startedFrom,
+            startedTo: this.queryParams?.startedTo,
+            status: this.queryParams?.status
+        };
+        return requestNode;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ServiceTaskListCloudComponent, deps: [{ token: i1.ServiceTaskListCloudService }, { token: i2.AppConfigService }, { token: i3.TaskCloudService }, { token: i2.UserPreferencesService }, { token: TASK_LIST_PREFERENCES_SERVICE_TOKEN }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ServiceTaskListCloudComponent, isStandalone: true, selector: "adf-cloud-service-task-list", inputs: { queryParams: "queryParams" }, usesInheritance: true, ngImport: i0, template: "<div *ngIf=\"!rows\">{{ 'ADF_CLOUD_TASK_LIST.FILTERS.MESSAGES.NONE' | translate }}</div>\n<ng-container *ngIf=\"rows\">\n        <adf-datatable\n            [rows]=\"rows\"\n            [columns]=\"columns\"\n            [data]=\"dataAdapter\"\n            [loading]=\"isLoading$ | async\"\n            [sorting]=\"formattedSorting\"\n            [multiselect]=\"multiselect\"\n            [selectionMode]=\"selectionMode\"\n            [stickyHeader]=\"stickyHeader\"\n            [actions]=\"showActions\"\n            [actionsPosition]=\"actionsPosition\"\n            [contextMenu]=\"showContextMenu\"\n            [resolverFn]=\"boundReplacePriorityValues\"\n            [showProvidedActions]=\"showProvidedActions\"\n            [showMainDatatableActions]=\"showMainDatatableActions\"\n            [isResizingEnabled]=\"isResizingEnabled\"\n            (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n            (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n            (executeRowAction)=\"onExecuteRowAction($event)\"\n            (row-select)=\"onRowSelect($any($event))\"\n            (row-unselect)=\"onRowUnselect($any($event))\"\n            (rowClick)=\"onRowClick($any($event))\"\n            (row-keyup)=\"onRowKeyUp($any($event))\"\n            (sorting-changed)=\"onSortingChanged($any($event))\"\n            (columnOrderChanged)=\"onColumnOrderChanged($event)\"\n            (columnsWidthChanged)=\"onColumnsWidthChanged($event)\"\n            >\n            <adf-loading-content-template>\n                <ng-template>\n                    <mat-progress-spinner\n                        class=\"adf-cloud-task-list-loading-margin\"\n                        [color]=\"'primary'\"\n                        [mode]=\"'indeterminate'\" />\n                </ng-template>\n            </adf-loading-content-template>\n            <adf-no-content-template>\n                <ng-template>\n                    <adf-empty-content\n                        *ngIf=\"!emptyCustomContent\"\n                        icon=\"assignment\"\n                        [title]=\"'ADF_CLOUD_TASK_LIST.LIST.MESSAGES.TITLE' | translate\"\n                        [subtitle]=\"'ADF_CLOUD_TASK_LIST.LIST.MESSAGES.SUBTITLE' | translate\" />\n                    <ng-content select=\"adf-custom-empty-content-template\" />\n                </ng-template>\n            </adf-no-content-template>\n\n            <adf-main-menu-datatable-template>\n                <ng-template let-mainMenuTrigger>\n                    <adf-datatable-column-selector\n                        [columns]=\"columns\"\n                        [mainMenuTrigger]=\"mainMenuTrigger\"\n                        (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n                </ng-template>\n            </adf-main-menu-datatable-template>\n        </adf-datatable>\n</ng-container>\n", styles: [".adf-cloud-task-list-loading-margin{margin-left:calc((100% - 100px)/2);margin-right:calc((100% - 100px)/2)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "component", type: ColumnsSelectorComponent, selector: "adf-datatable-column-selector", inputs: ["columns", "mainMenuTrigger", "columnsSorting", "maxColumnsVisible"], outputs: ["submitColumnsVisibility"] }, { kind: "directive", type: MainMenuDataTableTemplateDirective, selector: "adf-main-menu-datatable-template" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "component", type: EmptyContentComponent, selector: "adf-empty-content", inputs: ["icon", "title", "subtitle"] }, { kind: "directive", type: NoContentTemplateDirective, selector: "adf-no-content-template, no-content-template" }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i6.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: LoadingContentTemplateDirective, selector: "adf-loading-content-template, loading-content-template" }, { kind: "component", type: DataTableComponent, selector: "adf-datatable", inputs: ["data", "rows", "sorting", "columns", "selectionMode", "multiselect", "mainTableAction", "actions", "showMainDatatableActions", "showProvidedActions", "actionsPosition", "actionsVisibleOnHover", "fallbackThumbnail", "contextMenu", "rowStyle", "rowStyleClass", "showHeader", "stickyHeader", "loading", "noPermission", "rowMenuCacheEnabled", "resolverFn", "allowFiltering", "isResizingEnabled", "blurOnResize", "displayCheckboxesOnHover", "enableDragRows"], outputs: ["rowClick", "rowDblClick", "showRowContextMenu", "showRowActionsMenu", "executeRowAction", "columnOrderChanged", "columnsWidthChanged", "selectedItemsCountChanged", "dragDropped"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ServiceTaskListCloudComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-cloud-service-task-list', standalone: true, imports: [
+                        CommonModule,
+                        ColumnsSelectorComponent,
+                        MainMenuDataTableTemplateDirective,
+                        TranslateModule,
+                        EmptyContentComponent,
+                        NoContentTemplateDirective,
+                        MatProgressSpinnerModule,
+                        LoadingContentTemplateDirective,
+                        DataTableComponent
+                    ], encapsulation: ViewEncapsulation.None, template: "<div *ngIf=\"!rows\">{{ 'ADF_CLOUD_TASK_LIST.FILTERS.MESSAGES.NONE' | translate }}</div>\n<ng-container *ngIf=\"rows\">\n        <adf-datatable\n            [rows]=\"rows\"\n            [columns]=\"columns\"\n            [data]=\"dataAdapter\"\n            [loading]=\"isLoading$ | async\"\n            [sorting]=\"formattedSorting\"\n            [multiselect]=\"multiselect\"\n            [selectionMode]=\"selectionMode\"\n            [stickyHeader]=\"stickyHeader\"\n            [actions]=\"showActions\"\n            [actionsPosition]=\"actionsPosition\"\n            [contextMenu]=\"showContextMenu\"\n            [resolverFn]=\"boundReplacePriorityValues\"\n            [showProvidedActions]=\"showProvidedActions\"\n            [showMainDatatableActions]=\"showMainDatatableActions\"\n            [isResizingEnabled]=\"isResizingEnabled\"\n            (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n            (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n            (executeRowAction)=\"onExecuteRowAction($event)\"\n            (row-select)=\"onRowSelect($any($event))\"\n            (row-unselect)=\"onRowUnselect($any($event))\"\n            (rowClick)=\"onRowClick($any($event))\"\n            (row-keyup)=\"onRowKeyUp($any($event))\"\n            (sorting-changed)=\"onSortingChanged($any($event))\"\n            (columnOrderChanged)=\"onColumnOrderChanged($event)\"\n            (columnsWidthChanged)=\"onColumnsWidthChanged($event)\"\n            >\n            <adf-loading-content-template>\n                <ng-template>\n                    <mat-progress-spinner\n                        class=\"adf-cloud-task-list-loading-margin\"\n                        [color]=\"'primary'\"\n                        [mode]=\"'indeterminate'\" />\n                </ng-template>\n            </adf-loading-content-template>\n            <adf-no-content-template>\n                <ng-template>\n                    <adf-empty-content\n                        *ngIf=\"!emptyCustomContent\"\n                        icon=\"assignment\"\n                        [title]=\"'ADF_CLOUD_TASK_LIST.LIST.MESSAGES.TITLE' | translate\"\n                        [subtitle]=\"'ADF_CLOUD_TASK_LIST.LIST.MESSAGES.SUBTITLE' | translate\" />\n                    <ng-content select=\"adf-custom-empty-content-template\" />\n                </ng-template>\n            </adf-no-content-template>\n\n            <adf-main-menu-datatable-template>\n                <ng-template let-mainMenuTrigger>\n                    <adf-datatable-column-selector\n                        [columns]=\"columns\"\n                        [mainMenuTrigger]=\"mainMenuTrigger\"\n                        (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n                </ng-template>\n            </adf-main-menu-datatable-template>\n        </adf-datatable>\n</ng-container>\n", styles: [".adf-cloud-task-list-loading-margin{margin-left:calc((100% - 100px)/2);margin-right:calc((100% - 100px)/2)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ServiceTaskListCloudService }, { type: i2.AppConfigService }, { type: i3.TaskCloudService }, { type: i2.UserPreferencesService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TASK_LIST_PREFERENCES_SERVICE_TOKEN]
+                }] }], propDecorators: { queryParams: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-task-list-cloud.component.js","sourceRoot":"","sources":["../../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/components/service-task-list/service-task-list-cloud.component.ts","../../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/components/service-task-list/service-task-list-cloud.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (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 *     http://www.apache.org/licenses/LICENSE-2.0\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 { Component, Inject, Input, ViewEncapsulation } from '@angular/core';\nimport {\n    AppConfigService,\n    ColumnsSelectorComponent,\n    DataTableComponent,\n    EmptyContentComponent,\n    LoadingContentTemplateDirective,\n    MainMenuDataTableTemplateDirective,\n    NoContentTemplateDirective,\n    UserPreferencesService\n} from '@alfresco/adf-core';\nimport { ServiceTaskQueryCloudRequestModel } from '../../models/service-task-cloud.model';\nimport { BaseTaskListCloudComponent } from '../base-task-list-cloud.component';\nimport { ServiceTaskListCloudService } from '../../services/service-task-list-cloud.service';\nimport { TaskCloudService } from '../../../services/task-cloud.service';\nimport { BehaviorSubject, combineLatest } from 'rxjs';\nimport { PreferenceCloudServiceInterface, TASK_LIST_PREFERENCES_SERVICE_TOKEN } from '../../../../services/public-api';\nimport { map } from 'rxjs/operators';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { CommonModule } from '@angular/common';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\n\nconst PRESET_KEY = 'adf-cloud-service-task-list.presets';\n\n@Component({\n    selector: 'adf-cloud-service-task-list',\n    standalone: true,\n    imports: [\n        CommonModule,\n        ColumnsSelectorComponent,\n        MainMenuDataTableTemplateDirective,\n        TranslateModule,\n        EmptyContentComponent,\n        NoContentTemplateDirective,\n        MatProgressSpinnerModule,\n        LoadingContentTemplateDirective,\n        DataTableComponent\n    ],\n    templateUrl: './service-task-list-cloud.component.html',\n    styleUrls: ['./service-task-list-cloud.component.scss'],\n    encapsulation: ViewEncapsulation.None\n})\nexport class ServiceTaskListCloudComponent extends BaseTaskListCloudComponent {\n    @Input()\n    queryParams: { [key: string]: any } = {};\n\n    private isReloadingSubject$ = new BehaviorSubject<boolean>(false);\n    isLoading$ = combineLatest([this.isLoadingPreferences$, this.isReloadingSubject$]).pipe(\n        map(([isLoadingPreferences, isReloading]) => isLoadingPreferences || isReloading)\n    );\n\n    constructor(\n        private serviceTaskListCloudService: ServiceTaskListCloudService,\n        appConfigService: AppConfigService,\n        taskCloudService: TaskCloudService,\n        userPreferences: UserPreferencesService,\n        @Inject(TASK_LIST_PREFERENCES_SERVICE_TOKEN) cloudPreferenceService: PreferenceCloudServiceInterface\n    ) {\n        super(appConfigService, taskCloudService, userPreferences, PRESET_KEY, cloudPreferenceService);\n    }\n\n    reload() {\n        this.isReloadingSubject$.next(true);\n\n        this.requestNode = this.createRequestNode();\n\n        if (this.requestNode.appName || this.requestNode.appName === '') {\n            combineLatest([this.serviceTaskListCloudService.getServiceTaskByRequest(this.requestNode), this.isColumnSchemaCreated$])\n                .pipe(takeUntilDestroyed(this.destroyRef))\n                .subscribe(\n                    ([tasks]) => {\n                        this.rows = tasks.list.entries.map((task) => task.entry);\n                        this.success.emit(tasks);\n                        this.pagination.next(tasks.list.pagination);\n                        this.isReloadingSubject$.next(false);\n                    },\n                    (error) => {\n                        this.error.emit(error);\n                        this.isReloadingSubject$.next(false);\n                    }\n                );\n        } else {\n            this.rows = [];\n        }\n    }\n\n    createRequestNode(): ServiceTaskQueryCloudRequestModel {\n        const requestNode: ServiceTaskQueryCloudRequestModel = {\n            appName: this.appName,\n            maxItems: this.size,\n            skipCount: this.skipCount,\n            sorting: this.sorting,\n            id: this.queryParams?.serviceTaskId,\n            environmentId: this.queryParams?.environmentId,\n            activityName: this.queryParams?.activityName,\n            activityType: this.queryParams?.activityType,\n            completedDate: this.queryParams?.completedDate,\n            completedFrom: this.queryParams?.completedFrom,\n            completedTo: this.queryParams?.completedTo,\n            elementId: this.queryParams?.elementId,\n            executionId: this.queryParams?.executionId,\n            processDefinitionId: this.queryParams?.processDefinitionId,\n            processDefinitionKey: this.queryParams?.processDefinitionKey,\n            processDefinitionVersion: this.queryParams?.processDefinitionVersion,\n            processInstanceId: this.queryParams?.processInstanceId,\n            serviceFullName: this.queryParams?.serviceFullName,\n            serviceName: this.queryParams?.serviceName,\n            serviceVersion: this.queryParams?.serviceVersion,\n            startedDate: this.queryParams?.startedDate,\n            startedFrom: this.queryParams?.startedFrom,\n            startedTo: this.queryParams?.startedTo,\n            status: this.queryParams?.status\n        } as ServiceTaskQueryCloudRequestModel;\n        return requestNode;\n    }\n}\n","<div *ngIf=\"!rows\">{{ 'ADF_CLOUD_TASK_LIST.FILTERS.MESSAGES.NONE' | translate }}</div>\n<ng-container *ngIf=\"rows\">\n        <adf-datatable\n            [rows]=\"rows\"\n            [columns]=\"columns\"\n            [data]=\"dataAdapter\"\n            [loading]=\"isLoading$ | async\"\n            [sorting]=\"formattedSorting\"\n            [multiselect]=\"multiselect\"\n            [selectionMode]=\"selectionMode\"\n            [stickyHeader]=\"stickyHeader\"\n            [actions]=\"showActions\"\n            [actionsPosition]=\"actionsPosition\"\n            [contextMenu]=\"showContextMenu\"\n            [resolverFn]=\"boundReplacePriorityValues\"\n            [showProvidedActions]=\"showProvidedActions\"\n            [showMainDatatableActions]=\"showMainDatatableActions\"\n            [isResizingEnabled]=\"isResizingEnabled\"\n            (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n            (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n            (executeRowAction)=\"onExecuteRowAction($event)\"\n            (row-select)=\"onRowSelect($any($event))\"\n            (row-unselect)=\"onRowUnselect($any($event))\"\n            (rowClick)=\"onRowClick($any($event))\"\n            (row-keyup)=\"onRowKeyUp($any($event))\"\n            (sorting-changed)=\"onSortingChanged($any($event))\"\n            (columnOrderChanged)=\"onColumnOrderChanged($event)\"\n            (columnsWidthChanged)=\"onColumnsWidthChanged($event)\"\n            >\n            <adf-loading-content-template>\n                <ng-template>\n                    <mat-progress-spinner\n                        class=\"adf-cloud-task-list-loading-margin\"\n                        [color]=\"'primary'\"\n                        [mode]=\"'indeterminate'\" />\n                </ng-template>\n            </adf-loading-content-template>\n            <adf-no-content-template>\n                <ng-template>\n                    <adf-empty-content\n                        *ngIf=\"!emptyCustomContent\"\n                        icon=\"assignment\"\n                        [title]=\"'ADF_CLOUD_TASK_LIST.LIST.MESSAGES.TITLE' | translate\"\n                        [subtitle]=\"'ADF_CLOUD_TASK_LIST.LIST.MESSAGES.SUBTITLE' | translate\" />\n                    <ng-content select=\"adf-custom-empty-content-template\" />\n                </ng-template>\n            </adf-no-content-template>\n\n            <adf-main-menu-datatable-template>\n                <ng-template let-mainMenuTrigger>\n                    <adf-datatable-column-selector\n                        [columns]=\"columns\"\n                        [mainMenuTrigger]=\"mainMenuTrigger\"\n                        (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n                </ng-template>\n            </adf-main-menu-datatable-template>\n        </adf-datatable>\n</ng-container>\n"]}

package/esm2022/lib/task/task-list/components/task-list/datatable/task-list-datatable-adapter.mjs

@@ -0,0 +1,31 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { ObjectDataTableAdapter } from '@alfresco/adf-core';
+import { PROCESS_LIST_CUSTOM_VARIABLE_COLUMN } from '../../../../../models/data-column-custom-data';
+export class TasksListDatatableAdapter extends ObjectDataTableAdapter {
+    constructor(data, schema) {
+        super(data, schema, 'server');
+    }
+    getColumnType(row, col) {
+        if (col.customData?.columnType === PROCESS_LIST_CUSTOM_VARIABLE_COLUMN) {
+            const columnType = row.obj.variablesMap?.[col.id]?.type;
+            return columnType ?? 'text';
+        }
+        return super.getColumnType(row, col);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1saXN0LWRhdGF0YWJsZS1hZGFwdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL3Byb2Nlc3Mtc2VydmljZXMtY2xvdWQvc3JjL2xpYi90YXNrL3Rhc2stbGlzdC9jb21wb25lbnRzL3Rhc2stbGlzdC9kYXRhdGFibGUvdGFzay1saXN0LWRhdGF0YWJsZS1hZGFwdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE9BQU8sRUFBdUIsc0JBQXNCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNqRixPQUFPLEVBQW1DLG1DQUFtQyxFQUFFLE1BQU0sK0NBQStDLENBQUM7QUFHckksTUFBTSxPQUFPLHlCQUEwQixTQUFRLHNCQUFzQjtJQUNqRSxZQUFZLElBQXNDLEVBQUUsTUFBcUQ7UUFDckcsS0FBSyxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUVELGFBQWEsQ0FBQyxHQUFZLEVBQUUsR0FBZ0Q7UUFDeEUsSUFBSSxHQUFHLENBQUMsVUFBVSxFQUFFLFVBQVUsS0FBSyxtQ0FBbUMsRUFBRSxDQUFDO1lBQ3JFLE1BQU0sVUFBVSxHQUFHLEdBQUcsQ0FBQyxHQUFHLENBQUMsWUFBWSxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLElBQUksQ0FBQztZQUN4RCxPQUFPLFVBQVUsSUFBSSxNQUFNLENBQUM7UUFDaEMsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDLGFBQWEsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDekMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBEYXRhQ29sdW1uLCBEYXRhUm93LCBPYmplY3REYXRhVGFibGVBZGFwdGVyIH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1jb3JlJztcbmltcG9ydCB7IFByb2Nlc3NMaXN0RGF0YUNvbHVtbkN1c3RvbURhdGEsIFBST0NFU1NfTElTVF9DVVNUT01fVkFSSUFCTEVfQ09MVU1OIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vbW9kZWxzL2RhdGEtY29sdW1uLWN1c3RvbS1kYXRhJztcbmltcG9ydCB7IFRhc2tJbnN0YW5jZUNsb3VkTGlzdFZpZXdNb2RlbCB9IGZyb20gJy4uLy4uLy4uL21vZGVscy90YXNrLWNsb3VkLXZpZXcubW9kZWwnO1xuXG5leHBvcnQgY2xhc3MgVGFza3NMaXN0RGF0YXRhYmxlQWRhcHRlciBleHRlbmRzIE9iamVjdERhdGFUYWJsZUFkYXB0ZXIge1xuICAgIGNvbnN0cnVjdG9yKGRhdGE6IFRhc2tJbnN0YW5jZUNsb3VkTGlzdFZpZXdNb2RlbFtdLCBzY2hlbWE6IERhdGFDb2x1bW48UHJvY2Vzc0xpc3REYXRhQ29sdW1uQ3VzdG9tRGF0YT5bXSkge1xuICAgICAgICBzdXBlcihkYXRhLCBzY2hlbWEsICdzZXJ2ZXInKTtcbiAgICB9XG5cbiAgICBnZXRDb2x1bW5UeXBlKHJvdzogRGF0YVJvdywgY29sOiBEYXRhQ29sdW1uPFByb2Nlc3NMaXN0RGF0YUNvbHVtbkN1c3RvbURhdGE+KTogc3RyaW5nIHtcbiAgICAgICAgaWYgKGNvbC5jdXN0b21EYXRhPy5jb2x1bW5UeXBlID09PSBQUk9DRVNTX0xJU1RfQ1VTVE9NX1ZBUklBQkxFX0NPTFVNTikge1xuICAgICAgICAgICAgY29uc3QgY29sdW1uVHlwZSA9IHJvdy5vYmoudmFyaWFibGVzTWFwPy5bY29sLmlkXT8udHlwZTtcbiAgICAgICAgICAgIHJldHVybiBjb2x1bW5UeXBlID8/ICd0ZXh0JztcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiBzdXBlci5nZXRDb2x1bW5UeXBlKHJvdywgY29sKTtcbiAgICB9XG59XG4iXX0=