@alfresco/adf-process-services-cloud 8.1.0-16120632321 → 8.1.0-16121703802

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

@@ -0,0 +1,389 @@
+/*!
+ * @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 { AdfDateFnsAdapter, AppConfigService, ColumnsSelectorComponent, DataTableComponent, EmptyContentComponent, LoadingContentTemplateDirective, MainMenuDataTableTemplateDirective, MOMENT_DATE_FORMATS, NoContentTemplateDirective, UserPreferencesService } from '@alfresco/adf-core';
+import { TaskListRequestModel, TaskQueryCloudRequestModel } from '../../../../models/filter-cloud-model';
+import { BaseTaskListCloudComponent } from '../base-task-list-cloud.component';
+import { TaskCloudService } from '../../../services/task-cloud.service';
+import { TASK_LIST_CLOUD_TOKEN, TASK_LIST_PREFERENCES_SERVICE_TOKEN } from '../../../../services/cloud-token.service';
+import { BehaviorSubject, combineLatest, Subject } from 'rxjs';
+import { filter, map, switchMap, take, tap } from 'rxjs/operators';
+import { VariableMapperService } from '../../../../services/variable-mapper.sevice';
+import { TasksListDatatableAdapter } from './datatable/task-list-datatable-adapter';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TaskListRequestSortingModel } from '../../../../models/task-list-sorting.model';
+import { CommonModule } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../../services/task-cloud.service";
+import * as i3 from "../../../../services/variable-mapper.sevice";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/progress-spinner";
+const PRESET_KEY = 'adf-cloud-task-list.presets';
+export class TaskListCloudComponent extends BaseTaskListCloudComponent {
+    constructor(taskListCloudService, appConfigService, taskCloudService, userPreferences, cloudPreferenceService, viewModelCreator) {
+        super(appConfigService, taskCloudService, userPreferences, PRESET_KEY, cloudPreferenceService);
+        this.taskListCloudService = taskListCloudService;
+        this.viewModelCreator = viewModelCreator;
+        /**
+         * The assignee of the process. Possible values are: "assignee" (the current user is the assignee),
+         * "candidate" (the current user is a task candidate", "group_x" (the task is assigned to a group
+         * where the current user is a member, no value (the current user is involved).
+         */
+        this.assignee = '';
+        /** Filter the tasks. Display only tasks with createdFrom equal to the supplied date. */
+        this.createdFrom = '';
+        /** Filter the tasks. Display only tasks with createdTo equal to the supplied date. */
+        this.createdTo = '';
+        /** Filter the tasks. Display only tasks with lastModifiedFrom equal to the supplied date. */
+        this.lastModifiedFrom = '';
+        /** Filter the tasks. Display only tasks with lastModifiedTo equal to the supplied date. */
+        this.lastModifiedTo = '';
+        /** Filter the tasks. Display only tasks with dueDate greater or equal than the supplied date. */
+        this.dueDateFrom = '';
+        /** Filter the tasks. Display only tasks with dueDate less or equal to the supplied date. */
+        this.dueDateTo = '';
+        /** Filter the tasks. Display only tasks with id equal to the supplied value. */
+        this.id = '';
+        /** Filter the tasks. Display only tasks with the supplied name. */
+        this.name = '';
+        /** Filter the tasks. Display only tasks with parentTaskId equal to the supplied value. */
+        this.parentTaskId = '';
+        /** Filter the tasks. Display only tasks with processDefinitionName equal to the supplied value. */
+        this.processDefinitionName = '';
+        /** Filter the tasks. Display only tasks with processDefinitionId equal to the supplied value. */
+        this.processDefinitionId = '';
+        /** Filter the tasks. Display only tasks with processInstanceId equal to the supplied value. */
+        this.processInstanceId = '';
+        /** Filter the tasks. Display only tasks with status equal to the supplied value. */
+        this.status = '';
+        /** Filter the tasks. Display only tasks with owner equal to the supplied value. */
+        this.owner = '';
+        /** Filter the tasks. Display only the tasks that belong to a process in case is false or tasks that doesn't belong to a process in case of true. */
+        this.standalone = false;
+        /** Filter the tasks. Display only tasks with completedDate equal to the supplied date. */
+        this.completedDate = '';
+        /** Filter the tasks. Display only tasks with completedFrom equal to the supplied date. */
+        this.completedFrom = '';
+        /** Filter the tasks. Display only tasks with completedTo equal to the supplied date. */
+        this.completedTo = '';
+        /** Filter the tasks. Display only tasks with candidateGroups equal to the supplied value. */
+        this.candidateGroupId = '';
+        /** From Activiti 8.7.0 forward, use the 'POST' value and array inputs to enable advanced filtering. */
+        this.searchApiMethod = 'GET';
+        /**
+         * Filter the tasks. Display only tasks with names matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.names = [];
+        /**
+         * Filter the tasks. Display only tasks with assignees whose usernames are present in the array.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.assignees = [];
+        /**
+         * Filter the tasks. Display only tasks with provided statuses.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.statuses = [];
+        /**
+         * Filter the tasks. Display only tasks under processes with provided definition names.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.processDefinitionNames = [];
+        /**
+         * Filter the tasks. Display only tasks with Ids matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.ids = [];
+        /**
+         * Filter the tasks. Display only tasks with parentTaskIds matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.parentIds = [];
+        /**
+         * Filter the tasks. Display only tasks with processInstanceIds matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.processInstanceIds = [];
+        /**
+         * Filter the tasks. Display only tasks under processes with provided names.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.processNames = [];
+        /**
+         * Filter the tasks. Display only tasks with provided priorities.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.priorities = [];
+        /**
+         * Filter the tasks. Display only tasks completed by users whose usernames are present in the array.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.completedByUsers = [];
+        this.rows = [];
+        this.isReloadingSubject$ = new BehaviorSubject(false);
+        this.isLoading$ = combineLatest([this.isLoadingPreferences$, this.isReloadingSubject$]).pipe(map(([isLoadingPreferences, isReloading]) => isLoadingPreferences || isReloading));
+        this.fetchProcessesTrigger$ = new Subject();
+        combineLatest([this.isLoadingPreferences$, this.isColumnSchemaCreated$, this.fetchProcessesTrigger$])
+            .pipe(tap(() => this.isReloadingSubject$.next(true)), filter(([isLoadingPreferences, isColumnSchemaCreated]) => !isLoadingPreferences && !!isColumnSchemaCreated), switchMap(() => {
+            if (this.searchApiMethod === 'POST') {
+                const requestNode = this.createTaskListRequestNode();
+                return this.taskListCloudService.fetchTaskList(requestNode).pipe(take(1));
+            }
+            else {
+                const requestNode = this.createRequestNode();
+                this.requestNode = requestNode;
+                return this.taskListCloudService.getTaskByRequest(requestNode);
+            }
+        }), takeUntilDestroyed())
+            .subscribe({
+            next: (tasks) => {
+                const tasksWithVariables = tasks.list.entries.map((task) => ({
+                    ...task,
+                    variables: task.processVariables
+                }));
+                this.rows = this.viewModelCreator.mapVariablesByColumnTitle(tasksWithVariables, this.columns);
+                this.dataAdapter = new TasksListDatatableAdapter(this.rows, this.columns);
+                this.success.emit(tasks);
+                this.isReloadingSubject$.next(false);
+                this.pagination.next(tasks.list.pagination);
+            },
+            error: (error) => {
+                console.error(error);
+                this.error.emit(error);
+                this.isReloadingSubject$.next(false);
+            }
+        });
+    }
+    reload() {
+        this.isReloadingSubject$.next(true);
+        this.fetchProcessesTrigger$.next();
+    }
+    createTaskListRequestNode() {
+        const requestNode = {
+            appName: this.appName,
+            pagination: {
+                maxItems: this.size,
+                skipCount: this.skipCount
+            },
+            sorting: this.getTaskListRequestSorting(),
+            onlyStandalone: this.standalone,
+            name: this.names,
+            processDefinitionName: this.processDefinitionNames,
+            id: this.ids,
+            parentId: this.parentIds,
+            processName: this.processNames,
+            processInstanceId: this.processInstanceIds,
+            priority: this.priorities,
+            status: this.statuses,
+            completedBy: this.completedByUsers,
+            assignee: this.assignees,
+            createdFrom: this.createdFrom,
+            createdTo: this.createdTo,
+            lastModifiedFrom: this.lastModifiedFrom,
+            lastModifiedTo: this.lastModifiedTo,
+            dueDateFrom: this.dueDateFrom,
+            dueDateTo: this.dueDateTo,
+            completedFrom: this.completedFrom,
+            completedTo: this.completedTo,
+            processVariableKeys: this.getRequestNodeVariables(),
+            processVariableFilters: this.processVariableFilters ?? []
+        };
+        return new TaskListRequestModel(requestNode);
+    }
+    createRequestNode() {
+        const requestNode = {
+            appName: this.appName,
+            assignee: this.assignee,
+            id: this.id,
+            name: this.name,
+            environmentId: this.environmentId,
+            parentTaskId: this.parentTaskId,
+            processDefinitionName: this.processDefinitionName,
+            processDefinitionId: this.processDefinitionId,
+            processInstanceId: this.processInstanceId,
+            owner: this.owner,
+            priority: this.priority,
+            lastModifiedFrom: this.lastModifiedFrom,
+            lastModifiedTo: this.lastModifiedTo,
+            dueDateFrom: this.dueDateFrom,
+            dueDateTo: this.dueDateTo,
+            status: this.status,
+            dueDate: this.dueDate,
+            createdDate: this.createdDate,
+            createdFrom: this.createdFrom,
+            createdTo: this.createdTo,
+            maxItems: this.size,
+            skipCount: this.skipCount,
+            sorting: this.sorting,
+            standalone: this.standalone,
+            completedBy: this.completedBy,
+            completedFrom: this.completedFrom,
+            completedTo: this.completedTo,
+            completedDate: this.completedDate,
+            candidateGroupId: this.candidateGroupId,
+            variableKeys: this.getRequestNodeVariables()
+        };
+        return new TaskQueryCloudRequestModel(requestNode);
+    }
+    getRequestNodeVariables() {
+        const displayedVariableColumns = (this.columns ?? [])
+            .filter((column) => column.customData?.columnType === 'process-variable-column' && column.isHidden !== true)
+            .map((column) => {
+            const variableDefinitionsPayload = column.customData.variableDefinitionsPayload;
+            return variableDefinitionsPayload;
+        })
+            .reduce((allRequestKeys, requestKeys) => [...requestKeys, ...allRequestKeys], []);
+        return displayedVariableColumns.length ? displayedVariableColumns : undefined;
+    }
+    getTaskListRequestSorting() {
+        if (!this.sorting?.length) {
+            return new TaskListRequestSortingModel({
+                orderBy: this.defaultSorting.key,
+                direction: this.defaultSorting.direction,
+                isFieldProcessVariable: false
+            });
+        }
+        const orderBy = this.sorting[0]?.orderBy;
+        const direction = this.sorting[0]?.direction;
+        const orderByColumn = this.columnList?.columns.find((column) => column.key === orderBy);
+        const isFieldProcessVariable = orderByColumn?.customData?.columnType === 'process-variable-column';
+        if (isFieldProcessVariable) {
+            const processDefinitionKey = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[0];
+            const variableName = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[1];
+            return new TaskListRequestSortingModel({
+                orderBy: variableName,
+                direction,
+                isFieldProcessVariable: true,
+                processVariableData: {
+                    processDefinitionKey,
+                    type: orderByColumn.customData.variableType
+                }
+            });
+        }
+        else {
+            return new TaskListRequestSortingModel({ orderBy, direction, isFieldProcessVariable: false });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudComponent, deps: [{ token: TASK_LIST_CLOUD_TOKEN }, { token: i1.AppConfigService }, { token: i2.TaskCloudService }, { token: i1.UserPreferencesService }, { token: TASK_LIST_PREFERENCES_SERVICE_TOKEN }, { token: i3.VariableMapperService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TaskListCloudComponent, isStandalone: true, selector: "adf-cloud-task-list", inputs: { assignee: "assignee", createdDate: "createdDate", createdFrom: "createdFrom", createdTo: "createdTo", dueDate: "dueDate", lastModifiedFrom: "lastModifiedFrom", lastModifiedTo: "lastModifiedTo", dueDateFrom: "dueDateFrom", dueDateTo: "dueDateTo", id: "id", name: "name", environmentId: "environmentId", parentTaskId: "parentTaskId", processDefinitionName: "processDefinitionName", processDefinitionId: "processDefinitionId", processInstanceId: "processInstanceId", status: "status", owner: "owner", priority: "priority", completedBy: "completedBy", standalone: "standalone", completedDate: "completedDate", completedFrom: "completedFrom", completedTo: "completedTo", candidateGroupId: "candidateGroupId", searchApiMethod: "searchApiMethod", names: "names", assignees: "assignees", statuses: "statuses", processDefinitionNames: "processDefinitionNames", ids: "ids", parentIds: "parentIds", processInstanceIds: "processInstanceIds", processNames: "processNames", priorities: "priorities", completedByUsers: "completedByUsers", processVariableFilters: "processVariableFilters" }, providers: [
+            { provide: DateAdapter, useClass: AdfDateFnsAdapter },
+            { provide: MAT_DATE_FORMATS, useValue: MOMENT_DATE_FORMATS }
+        ], 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: "pipe", type: 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: i5.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: TaskListCloudComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-cloud-task-list', standalone: true, imports: [
+                        CommonModule,
+                        ColumnsSelectorComponent,
+                        MainMenuDataTableTemplateDirective,
+                        TranslatePipe,
+                        EmptyContentComponent,
+                        NoContentTemplateDirective,
+                        MatProgressSpinnerModule,
+                        LoadingContentTemplateDirective,
+                        DataTableComponent
+                    ], providers: [
+                        { provide: DateAdapter, useClass: AdfDateFnsAdapter },
+                        { provide: MAT_DATE_FORMATS, useValue: MOMENT_DATE_FORMATS }
+                    ], 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: undefined, decorators: [{
+                    type: Inject,
+                    args: [TASK_LIST_CLOUD_TOKEN]
+                }] }, { type: i1.AppConfigService }, { type: i2.TaskCloudService }, { type: i1.UserPreferencesService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TASK_LIST_PREFERENCES_SERVICE_TOKEN]
+                }] }, { type: i3.VariableMapperService }], propDecorators: { assignee: [{
+                type: Input
+            }], createdDate: [{
+                type: Input
+            }], createdFrom: [{
+                type: Input
+            }], createdTo: [{
+                type: Input
+            }], dueDate: [{
+                type: Input
+            }], lastModifiedFrom: [{
+                type: Input
+            }], lastModifiedTo: [{
+                type: Input
+            }], dueDateFrom: [{
+                type: Input
+            }], dueDateTo: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], environmentId: [{
+                type: Input
+            }], parentTaskId: [{
+                type: Input
+            }], processDefinitionName: [{
+                type: Input
+            }], processDefinitionId: [{
+                type: Input
+            }], processInstanceId: [{
+                type: Input
+            }], status: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], priority: [{
+                type: Input
+            }], completedBy: [{
+                type: Input
+            }], standalone: [{
+                type: Input
+            }], completedDate: [{
+                type: Input
+            }], completedFrom: [{
+                type: Input
+            }], completedTo: [{
+                type: Input
+            }], candidateGroupId: [{
+                type: Input
+            }], searchApiMethod: [{
+                type: Input
+            }], names: [{
+                type: Input
+            }], assignees: [{
+                type: Input
+            }], statuses: [{
+                type: Input
+            }], processDefinitionNames: [{
+                type: Input
+            }], ids: [{
+                type: Input
+            }], parentIds: [{
+                type: Input
+            }], processInstanceIds: [{
+                type: Input
+            }], processNames: [{
+                type: Input
+            }], priorities: [{
+                type: Input
+            }], completedByUsers: [{
+                type: Input
+            }], processVariableFilters: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-list-cloud.component.js","sourceRoot":"","sources":["../../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/components/task-list/task-list-cloud.component.ts","../../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/components/task-list/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    AdfDateFnsAdapter,\n    AppConfigService,\n    ColumnsSelectorComponent,\n    DataTableComponent,\n    EmptyContentComponent,\n    LoadingContentTemplateDirective,\n    MainMenuDataTableTemplateDirective,\n    MOMENT_DATE_FORMATS,\n    NoContentTemplateDirective,\n    UserPreferencesService\n} from '@alfresco/adf-core';\nimport { TaskListRequestModel, TaskQueryCloudRequestModel } from '../../../../models/filter-cloud-model';\nimport { BaseTaskListCloudComponent } from '../base-task-list-cloud.component';\nimport { TaskCloudService } from '../../../services/task-cloud.service';\nimport { TASK_LIST_CLOUD_TOKEN, TASK_LIST_PREFERENCES_SERVICE_TOKEN } from '../../../../services/cloud-token.service';\nimport { PreferenceCloudServiceInterface } from '../../../../services/preference-cloud.interface';\nimport { TaskListCloudServiceInterface } from '../../../../services/task-list-cloud.service.interface';\nimport { BehaviorSubject, combineLatest, Subject } from 'rxjs';\nimport { filter, map, switchMap, take, tap } from 'rxjs/operators';\nimport { VariableMapperService } from '../../../../services/variable-mapper.sevice';\nimport { ProcessListDataColumnCustomData } from '../../../../models/data-column-custom-data';\nimport { TaskCloudModel } from '../../../../models/task-cloud.model';\nimport { PaginatedEntries } from '@alfresco/js-api';\nimport { TaskInstanceCloudListViewModel } from '../../models/task-cloud-view.model';\nimport { TasksListDatatableAdapter } from './datatable/task-list-datatable-adapter';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { TaskListRequestSortingModel } from '../../../../models/task-list-sorting.model';\nimport { ProcessVariableFilterModel } from '../../../../models/process-variable-filter.model';\nimport { CommonModule } from '@angular/common';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';\n\nconst PRESET_KEY = 'adf-cloud-task-list.presets';\n\n@Component({\n    selector: 'adf-cloud-task-list',\n    standalone: true,\n    imports: [\n        CommonModule,\n        ColumnsSelectorComponent,\n        MainMenuDataTableTemplateDirective,\n        TranslatePipe,\n        EmptyContentComponent,\n        NoContentTemplateDirective,\n        MatProgressSpinnerModule,\n        LoadingContentTemplateDirective,\n        DataTableComponent\n    ],\n    providers: [\n        { provide: DateAdapter, useClass: AdfDateFnsAdapter },\n        { provide: MAT_DATE_FORMATS, useValue: MOMENT_DATE_FORMATS }\n    ],\n    templateUrl: './task-list-cloud.component.html',\n    styleUrls: ['./task-list-cloud.component.scss'],\n    encapsulation: ViewEncapsulation.None\n})\nexport class TaskListCloudComponent extends BaseTaskListCloudComponent<ProcessListDataColumnCustomData> {\n    /**\n     * The assignee of the process. Possible values are: \"assignee\" (the current user is the assignee),\n     * \"candidate\" (the current user is a task candidate\", \"group_x\" (the task is assigned to a group\n     * where the current user is a member, no value (the current user is involved).\n     */\n    @Input()\n    assignee: string = '';\n\n    /** Filter the tasks. Display only tasks created on the supplied date. */\n    @Input()\n    createdDate: Date;\n\n    /** Filter the tasks. Display only tasks with createdFrom equal to the supplied date. */\n    @Input()\n    createdFrom: string = '';\n\n    /** Filter the tasks. Display only tasks with createdTo equal to the supplied date. */\n    @Input()\n    createdTo: string = '';\n\n    /** Filter the tasks. Display only tasks with dueDate equal to the supplied date. */\n    @Input()\n    dueDate: Date;\n\n    /** Filter the tasks. Display only tasks with lastModifiedFrom equal to the supplied date. */\n    @Input()\n    lastModifiedFrom: string = '';\n\n    /** Filter the tasks. Display only tasks with lastModifiedTo equal to the supplied date. */\n    @Input()\n    lastModifiedTo: string = '';\n\n    /** Filter the tasks. Display only tasks with dueDate greater or equal than the supplied date. */\n    @Input()\n    dueDateFrom: string = '';\n\n    /** Filter the tasks. Display only tasks with dueDate less or equal to the supplied date. */\n    @Input()\n    dueDateTo: string = '';\n\n    /** Filter the tasks. Display only tasks with id equal to the supplied value. */\n    @Input()\n    id: string = '';\n\n    /** Filter the tasks. Display only tasks with the supplied name. */\n    @Input()\n    name: string = '';\n\n    /** Filter the tasks to display only the ones with this environment ID. */\n    @Input()\n    environmentId: string;\n\n    /** Filter the tasks. Display only tasks with parentTaskId equal to the supplied value. */\n    @Input()\n    parentTaskId: string = '';\n\n    /** Filter the tasks. Display only tasks with processDefinitionName equal to the supplied value. */\n    @Input()\n    processDefinitionName: string = '';\n\n    /** Filter the tasks. Display only tasks with processDefinitionId equal to the supplied value. */\n    @Input()\n    processDefinitionId: string = '';\n\n    /** Filter the tasks. Display only tasks with processInstanceId equal to the supplied value. */\n    @Input()\n    processInstanceId: string = '';\n\n    /** Filter the tasks. Display only tasks with status equal to the supplied value. */\n    @Input()\n    status: string = '';\n\n    /** Filter the tasks. Display only tasks with owner equal to the supplied value. */\n    @Input()\n    owner: string = '';\n\n    /** Filter the tasks. Display only tasks with priority equal to the supplied value. */\n    @Input()\n    priority: number;\n\n    /** Filter the tasks. Display only tasks with createdBy equal to the supplied value. */\n    @Input()\n    completedBy: number;\n\n    /** Filter the tasks. Display only the tasks that belong to a process in case is false or tasks that doesn't belong to a process in case of true. */\n    @Input()\n    standalone: boolean = false;\n\n    /** Filter the tasks. Display only tasks with completedDate equal to the supplied date. */\n    @Input()\n    completedDate: string = '';\n\n    /** Filter the tasks. Display only tasks with completedFrom equal to the supplied date. */\n    @Input()\n    completedFrom: string = '';\n\n    /** Filter the tasks. Display only tasks with completedTo equal to the supplied date. */\n    @Input()\n    completedTo: string = '';\n\n    /** Filter the tasks. Display only tasks with candidateGroups equal to the supplied value. */\n    @Input()\n    candidateGroupId: string = '';\n\n    /** From Activiti 8.7.0 forward, use the 'POST' value and array inputs to enable advanced filtering. */\n    @Input()\n    searchApiMethod: 'GET' | 'POST' = 'GET';\n\n    /**\n     * Filter the tasks. Display only tasks with names matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    names: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks with assignees whose usernames are present in the array.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    assignees: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks with provided statuses.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    statuses: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks under processes with provided definition names.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    processDefinitionNames: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks with Ids matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    ids: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks with parentTaskIds matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    parentIds: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks with processInstanceIds matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    processInstanceIds: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks under processes with provided names.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    processNames: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks with provided priorities.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    priorities: string[] = [];\n\n    /**\n     * Filter the tasks. Display only tasks completed by users whose usernames are present in the array.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    completedByUsers: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes with specific process variables.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    processVariableFilters: ProcessVariableFilterModel[];\n\n    rows: TaskInstanceCloudListViewModel[] = [];\n    dataAdapter: TasksListDatatableAdapter | undefined;\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    private fetchProcessesTrigger$ = new Subject<void>();\n\n    constructor(\n        @Inject(TASK_LIST_CLOUD_TOKEN) public taskListCloudService: TaskListCloudServiceInterface,\n        appConfigService: AppConfigService,\n        taskCloudService: TaskCloudService,\n        userPreferences: UserPreferencesService,\n        @Inject(TASK_LIST_PREFERENCES_SERVICE_TOKEN) cloudPreferenceService: PreferenceCloudServiceInterface,\n        private viewModelCreator: VariableMapperService\n    ) {\n        super(appConfigService, taskCloudService, userPreferences, PRESET_KEY, cloudPreferenceService);\n\n        combineLatest([this.isLoadingPreferences$, this.isColumnSchemaCreated$, this.fetchProcessesTrigger$])\n            .pipe(\n                tap(() => this.isReloadingSubject$.next(true)),\n                filter(([isLoadingPreferences, isColumnSchemaCreated]) => !isLoadingPreferences && !!isColumnSchemaCreated),\n                switchMap(() => {\n                    if (this.searchApiMethod === 'POST') {\n                        const requestNode = this.createTaskListRequestNode();\n                        return this.taskListCloudService.fetchTaskList(requestNode).pipe(take(1));\n                    } else {\n                        const requestNode = this.createRequestNode();\n                        this.requestNode = requestNode;\n                        return this.taskListCloudService.getTaskByRequest(requestNode);\n                    }\n                }),\n                takeUntilDestroyed()\n            )\n            .subscribe({\n                next: (tasks: { list: PaginatedEntries<TaskCloudModel> }) => {\n                    const tasksWithVariables = tasks.list.entries.map((task) => ({\n                        ...task,\n                        variables: task.processVariables\n                    }));\n\n                    this.rows = this.viewModelCreator.mapVariablesByColumnTitle(tasksWithVariables, this.columns);\n\n                    this.dataAdapter = new TasksListDatatableAdapter(this.rows, this.columns);\n\n                    this.success.emit(tasks);\n                    this.isReloadingSubject$.next(false);\n                    this.pagination.next(tasks.list.pagination);\n                },\n                error: (error) => {\n                    console.error(error);\n                    this.error.emit(error);\n                    this.isReloadingSubject$.next(false);\n                }\n            });\n    }\n\n    reload() {\n        this.isReloadingSubject$.next(true);\n        this.fetchProcessesTrigger$.next();\n    }\n\n    private createTaskListRequestNode(): TaskListRequestModel {\n        const requestNode: TaskListRequestModel = {\n            appName: this.appName,\n            pagination: {\n                maxItems: this.size,\n                skipCount: this.skipCount\n            },\n            sorting: this.getTaskListRequestSorting(),\n            onlyStandalone: this.standalone,\n            name: this.names,\n            processDefinitionName: this.processDefinitionNames,\n            id: this.ids,\n            parentId: this.parentIds,\n            processName: this.processNames,\n            processInstanceId: this.processInstanceIds,\n            priority: this.priorities,\n            status: this.statuses,\n            completedBy: this.completedByUsers,\n            assignee: this.assignees,\n            createdFrom: this.createdFrom,\n            createdTo: this.createdTo,\n            lastModifiedFrom: this.lastModifiedFrom,\n            lastModifiedTo: this.lastModifiedTo,\n            dueDateFrom: this.dueDateFrom,\n            dueDateTo: this.dueDateTo,\n            completedFrom: this.completedFrom,\n            completedTo: this.completedTo,\n            processVariableKeys: this.getRequestNodeVariables(),\n            processVariableFilters: this.processVariableFilters ?? []\n        };\n\n        return new TaskListRequestModel(requestNode);\n    }\n\n    private createRequestNode(): TaskQueryCloudRequestModel {\n        const requestNode = {\n            appName: this.appName,\n            assignee: this.assignee,\n            id: this.id,\n            name: this.name,\n            environmentId: this.environmentId,\n            parentTaskId: this.parentTaskId,\n            processDefinitionName: this.processDefinitionName,\n            processDefinitionId: this.processDefinitionId,\n            processInstanceId: this.processInstanceId,\n            owner: this.owner,\n            priority: this.priority,\n            lastModifiedFrom: this.lastModifiedFrom,\n            lastModifiedTo: this.lastModifiedTo,\n            dueDateFrom: this.dueDateFrom,\n            dueDateTo: this.dueDateTo,\n            status: this.status,\n            dueDate: this.dueDate,\n            createdDate: this.createdDate,\n            createdFrom: this.createdFrom,\n            createdTo: this.createdTo,\n            maxItems: this.size,\n            skipCount: this.skipCount,\n            sorting: this.sorting,\n            standalone: this.standalone,\n            completedBy: this.completedBy,\n            completedFrom: this.completedFrom,\n            completedTo: this.completedTo,\n            completedDate: this.completedDate,\n            candidateGroupId: this.candidateGroupId,\n            variableKeys: this.getRequestNodeVariables()\n        };\n\n        return new TaskQueryCloudRequestModel(requestNode);\n    }\n\n    private getRequestNodeVariables(): string[] | undefined {\n        const displayedVariableColumns: string[] = (this.columns ?? [])\n            .filter((column) => column.customData?.columnType === 'process-variable-column' && column.isHidden !== true)\n            .map((column) => {\n                const variableDefinitionsPayload = column.customData.variableDefinitionsPayload;\n                return variableDefinitionsPayload;\n            })\n            .reduce((allRequestKeys, requestKeys) => [...requestKeys, ...allRequestKeys], []);\n\n        return displayedVariableColumns.length ? displayedVariableColumns : undefined;\n    }\n\n    private getTaskListRequestSorting(): TaskListRequestSortingModel {\n        if (!this.sorting?.length) {\n            return new TaskListRequestSortingModel({\n                orderBy: this.defaultSorting.key,\n                direction: this.defaultSorting.direction,\n                isFieldProcessVariable: false\n            });\n        }\n\n        const orderBy = this.sorting[0]?.orderBy;\n        const direction = this.sorting[0]?.direction;\n        const orderByColumn = this.columnList?.columns.find((column) => column.key === orderBy);\n        const isFieldProcessVariable = orderByColumn?.customData?.columnType === 'process-variable-column';\n\n        if (isFieldProcessVariable) {\n            const processDefinitionKey = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[0];\n            const variableName = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[1];\n            return new TaskListRequestSortingModel({\n                orderBy: variableName,\n                direction,\n                isFieldProcessVariable: true,\n                processVariableData: {\n                    processDefinitionKey,\n                    type: orderByColumn.customData.variableType\n                }\n            });\n        } else {\n            return new TaskListRequestSortingModel({ orderBy, direction, isFieldProcessVariable: false });\n        }\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/models/service-task-cloud.model.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1jbG91ZC12aWV3Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL3Byb2Nlc3Mtc2VydmljZXMtY2xvdWQvc3JjL2xpYi90YXNrL3Rhc2stbGlzdC9tb2RlbHMvdGFzay1jbG91ZC12aWV3Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgVGFza0Nsb3VkTW9kZWwgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMvdGFzay1jbG91ZC5tb2RlbCc7XG5pbXBvcnQgeyBXaXRoVmFyaWFibGVzTWFwIH0gZnJvbSAnLi4vLi4vLi4vbW9kZWxzL3Byb2Nlc3MtaW5zdGFuY2UtdmFyaWFibGUubW9kZWwnO1xuXG5leHBvcnQgdHlwZSBUYXNrSW5zdGFuY2VDbG91ZExpc3RWaWV3TW9kZWwgPSBXaXRoVmFyaWFibGVzTWFwPFRhc2tDbG91ZE1vZGVsPjtcbiJdfQ==

package/esm2022/lib/task/task-list/public-api.mjs

@@ -0,0 +1,23 @@
+/*!
+ * @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.
+ */
+export * from './components/task-list/task-list-cloud.component';
+export * from './components/service-task-list/service-task-list-cloud.component';
+export * from './models/service-task-cloud.model';
+export * from './services/task-list-cloud.service';
+export * from './services/service-task-list-cloud.service';
+export * from './task-list-cloud.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzLWNsb3VkL3NyYy9saWIvdGFzay90YXNrLWxpc3QvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsa0VBQWtFLENBQUM7QUFFakYsY0FBYyxtQ0FBbUMsQ0FBQztBQUVsRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsNENBQTRDLENBQUM7QUFFM0QsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3Rhc2stbGlzdC90YXNrLWxpc3QtY2xvdWQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9zZXJ2aWNlLXRhc2stbGlzdC9zZXJ2aWNlLXRhc2stbGlzdC1jbG91ZC5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zZXJ2aWNlLXRhc2stY2xvdWQubW9kZWwnO1xuXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3Rhc2stbGlzdC1jbG91ZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvc2VydmljZS10YXNrLWxpc3QtY2xvdWQuc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vdGFzay1saXN0LWNsb3VkLm1vZHVsZSc7XG4iXX0=