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

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

@@ -0,0 +1,115 @@
+/*!
+ * @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 { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class ServiceTaskListCloudService extends BaseCloudService {
+    /**
+     * Finds a task using an object with optional query properties.
+     *
+     * @param requestNode Query object
+     * @returns Task information
+     */
+    getServiceTaskByRequest(requestNode) {
+        if (requestNode.appName || requestNode.appName === '') {
+            const queryUrl = `${this.getBasePath(requestNode.appName)}/query/admin/v1/service-tasks`;
+            const queryParams = this.buildQueryParams(requestNode);
+            const sortingParams = this.buildSortingParam(requestNode.sorting);
+            if (sortingParams) {
+                queryParams['sort'] = sortingParams;
+            }
+            return this.get(queryUrl, queryParams);
+        }
+        else {
+            return throwError('Appname not configured');
+        }
+    }
+    /**
+     * Finds a service task integration context using an object with optional query properties.
+     *
+     * @param appName string
+     * @param serviceTaskId string
+     * @returns Service Task Integration Context information
+     */
+    getServiceTaskStatus(appName, serviceTaskId) {
+        if (appName) {
+            const queryUrl = `${this.getBasePath(appName)}/query/admin/v1/service-tasks/${serviceTaskId}/integration-context`;
+            return this.get(queryUrl).pipe(map((response) => response.entry));
+        }
+        else {
+            return throwError('Appname not configured');
+        }
+    }
+    /**
+     * Replay a service task based on the related execution id and flow-node id
+     *
+     * @param appName string
+     * @param executionId string
+     * @param flowNodeId string
+     * @returns Replay task informations
+     */
+    replayServiceTaskRequest(appName, executionId, flowNodeId) {
+        if (appName && executionId && flowNodeId) {
+            const payload = { flowNodeId };
+            const queryUrl = `${this.getBasePath(appName)}/rb/admin/v1/executions/${executionId}/replay/service-task`;
+            return this.post(queryUrl, payload);
+        }
+        else {
+            return throwError('Appname/executionId/flowNodeId not configured');
+        }
+    }
+    buildQueryParams(requestNode) {
+        const queryParam = {};
+        for (const property in requestNode) {
+            if (Object.prototype.hasOwnProperty.call(requestNode, property) &&
+                !this.isExcludedField(property) &&
+                this.isPropertyValueValid(requestNode, property)) {
+                queryParam[property] = requestNode[property];
+            }
+        }
+        return queryParam;
+    }
+    isExcludedField(property) {
+        return property === 'appName' || property === 'sorting';
+    }
+    isPropertyValueValid(requestNode, property) {
+        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;
+    }
+    buildSortingParam(models) {
+        let finalSorting = '';
+        if (models) {
+            for (const sort of models) {
+                if (!finalSorting) {
+                    finalSorting = `${sort.orderBy},${sort.direction}`;
+                }
+                else {
+                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;
+                }
+            }
+        }
+        return encodeURI(finalSorting);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ServiceTaskListCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ServiceTaskListCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ServiceTaskListCloudService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-task-list-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/services/service-task-list-cloud.service.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 { Injectable } from '@angular/core';\nimport { ServiceTaskQueryCloudRequestModel, ServiceTaskIntegrationContextCloudModel } from '../models/service-task-cloud.model';\nimport { Observable, throwError } from 'rxjs';\nimport { TaskListCloudSortingModel } from '../../../models/task-list-sorting.model';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { map } from 'rxjs/operators';\n\n@Injectable({ providedIn: 'root' })\nexport class ServiceTaskListCloudService extends BaseCloudService {\n    /**\n     * Finds a task using an object with optional query properties.\n     *\n     * @param requestNode Query object\n     * @returns Task information\n     */\n    getServiceTaskByRequest(requestNode: ServiceTaskQueryCloudRequestModel): Observable<any> {\n        if (requestNode.appName || requestNode.appName === '') {\n            const queryUrl = `${this.getBasePath(requestNode.appName)}/query/admin/v1/service-tasks`;\n            const queryParams = this.buildQueryParams(requestNode);\n            const sortingParams = this.buildSortingParam(requestNode.sorting);\n            if (sortingParams) {\n                queryParams['sort'] = sortingParams;\n            }\n            return this.get(queryUrl, queryParams);\n        } else {\n            return throwError('Appname not configured');\n        }\n    }\n\n    /**\n     * Finds a service task integration context using an object with optional query properties.\n     *\n     * @param appName string\n     * @param serviceTaskId string\n     * @returns Service Task Integration Context information\n     */\n    getServiceTaskStatus(appName: string, serviceTaskId: string): Observable<ServiceTaskIntegrationContextCloudModel> {\n        if (appName) {\n            const queryUrl = `${this.getBasePath(appName)}/query/admin/v1/service-tasks/${serviceTaskId}/integration-context`;\n            return this.get(queryUrl).pipe(map((response: any) => response.entry));\n        } else {\n            return throwError('Appname not configured');\n        }\n    }\n\n    /**\n     * Replay a service task based on the related execution id and flow-node id\n     *\n     * @param appName string\n     * @param executionId string\n     * @param flowNodeId string\n     * @returns Replay task informations\n     */\n    replayServiceTaskRequest(appName: string, executionId: string, flowNodeId: string): Observable<any> {\n        if (appName && executionId && flowNodeId) {\n            const payload = { flowNodeId };\n            const queryUrl = `${this.getBasePath(appName)}/rb/admin/v1/executions/${executionId}/replay/service-task`;\n            return this.post(queryUrl, payload);\n        } else {\n            return throwError('Appname/executionId/flowNodeId not configured');\n        }\n    }\n\n    protected buildQueryParams(requestNode: ServiceTaskQueryCloudRequestModel): any {\n        const queryParam: any = {};\n        for (const property in requestNode) {\n            if (\n                Object.prototype.hasOwnProperty.call(requestNode, property) &&\n                !this.isExcludedField(property) &&\n                this.isPropertyValueValid(requestNode, property)\n            ) {\n                queryParam[property] = requestNode[property];\n            }\n        }\n        return queryParam;\n    }\n\n    protected isExcludedField(property: string): boolean {\n        return property === 'appName' || property === 'sorting';\n    }\n\n    protected isPropertyValueValid(requestNode: any, property: string): boolean {\n        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;\n    }\n\n    protected buildSortingParam(models: TaskListCloudSortingModel[]): string {\n        let finalSorting: string = '';\n        if (models) {\n            for (const sort of models) {\n                if (!finalSorting) {\n                    finalSorting = `${sort.orderBy},${sort.direction}`;\n                } else {\n                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;\n                }\n            }\n        }\n        return encodeURI(finalSorting);\n    }\n}\n"]}

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

@@ -0,0 +1,178 @@
+/*!
+ * @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 { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class TaskListCloudService extends BaseCloudService {
+    /**
+     * Finds a task using an object with optional query properties.
+     *
+     * @deprecated From Activiti 8.7.0 forward, use TaskListCloudService.fetchTaskList instead.
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns Task information
+     */
+    getTaskByRequest(requestNode, queryUrl) {
+        if (requestNode.appName || requestNode.appName === '') {
+            queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/tasks`;
+            const queryParams = this.buildQueryParams(requestNode);
+            const sortingParams = this.buildSortingParam(requestNode.sorting);
+            if (sortingParams) {
+                queryParams['sort'] = sortingParams;
+            }
+            return this.get(queryUrl, queryParams).pipe(map((response) => {
+                const entries = response.list?.entries;
+                if (entries) {
+                    // TODO: this looks like a hack of the TaskCloudNodePaging collection
+                    response.list.entries = entries.map((entryData) => entryData.entry);
+                }
+                return response;
+            }));
+        }
+        else {
+            return throwError('Appname not configured');
+        }
+    }
+    /**
+     * Available from Activiti version 8.7.0 onwards.
+     * Retrieves a list of tasks using an object with optional query properties.
+     *
+     * @param requestNode Query object
+     * @param queryUrl Query url
+     * @returns List of tasks
+     */
+    fetchTaskList(requestNode, queryUrl) {
+        if (!requestNode?.appName) {
+            return throwError(() => new Error('Appname not configured'));
+        }
+        queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/tasks/search`;
+        const queryParams = {
+            maxItems: requestNode.pagination?.maxItems || 25,
+            skipCount: requestNode.pagination?.skipCount || 0
+        };
+        const queryData = this.buildQueryData(requestNode);
+        return this.post(queryUrl, queryData, queryParams).pipe(map((response) => {
+            const entries = response.list?.entries;
+            if (entries) {
+                response.list.entries = entries.map((entryData) => entryData.entry);
+            }
+            return response;
+        }));
+    }
+    getTaskListCounter(requestNode) {
+        if (!requestNode.appName) {
+            return throwError(() => new Error('Appname not configured'));
+        }
+        return this.fetchTaskList(requestNode).pipe(map((tasks) => tasks.list.pagination.totalItems));
+    }
+    buildQueryData(requestNode) {
+        const queryData = {
+            id: requestNode.id,
+            parentId: requestNode.parentId,
+            processInstanceId: requestNode.processInstanceId,
+            status: requestNode.status,
+            processDefinitionName: requestNode.processDefinitionName,
+            processName: requestNode.processName,
+            assignee: requestNode.assignee,
+            priority: requestNode.priority,
+            name: requestNode.name,
+            completedBy: requestNode.completedBy,
+            completedFrom: requestNode.completedFrom,
+            completedTo: requestNode.completedTo,
+            createdFrom: requestNode.createdFrom,
+            createdTo: requestNode.createdTo,
+            dueDateFrom: requestNode.dueDateFrom,
+            dueDateTo: requestNode.dueDateTo,
+            processVariableKeys: requestNode.processVariableKeys,
+            processVariableFilters: requestNode.processVariableFilters
+        };
+        if (requestNode.sorting) {
+            queryData['sort'] = {
+                field: requestNode.sorting.orderBy,
+                direction: requestNode.sorting.direction.toLowerCase(),
+                isProcessVariable: requestNode.sorting.isFieldProcessVariable
+            };
+            if (queryData['sort'].isProcessVariable) {
+                queryData['sort'].processDefinitionKey = requestNode.sorting.processVariableData?.processDefinitionKey;
+                queryData['sort'].type = requestNode.sorting.processVariableData?.type;
+            }
+        }
+        /*
+         * Remove process variable filter keys with empty values from the query data.
+         */
+        if (queryData['processVariableFilters']) {
+            queryData['processVariableFilters'] = queryData['processVariableFilters'].filter((filter) => filter.value !== '' && filter.value !== null && filter.value !== undefined);
+        }
+        /*
+         * Remove keys with empty values from the query data.
+         */
+        Object.keys(queryData).forEach((key) => {
+            const value = queryData[key];
+            const isValueEmpty = !value;
+            const isValueArrayWithEmptyValue = Array.isArray(value) && (value.length === 0 || value[0] === null);
+            if (isValueEmpty || isValueArrayWithEmptyValue) {
+                delete queryData[key];
+            }
+        });
+        return queryData;
+    }
+    buildQueryParams(requestNode) {
+        const queryParam = {};
+        for (const propertyKey in requestNode) {
+            if (Object.prototype.hasOwnProperty.call(requestNode, propertyKey) &&
+                !this.isExcludedField(propertyKey) &&
+                this.isPropertyValueValid(requestNode, propertyKey)) {
+                if (propertyKey === 'variableKeys' && requestNode[propertyKey]?.length > 0) {
+                    queryParam[propertyKey] = requestNode[propertyKey].join(',');
+                }
+                else {
+                    queryParam[propertyKey] = requestNode[propertyKey];
+                }
+            }
+        }
+        return queryParam;
+    }
+    isExcludedField(property) {
+        return property === 'appName' || property === 'sorting';
+    }
+    isPropertyValueValid(requestNode, property) {
+        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;
+    }
+    buildSortingParam(models) {
+        let finalSorting = '';
+        if (models) {
+            for (const sort of models) {
+                if (!finalSorting) {
+                    finalSorting = `${sort.orderBy},${sort.direction}`;
+                }
+                else {
+                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;
+                }
+            }
+        }
+        return encodeURI(finalSorting);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-list-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/task/task-list/services/task-list-cloud.service.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 { Injectable } from '@angular/core';\nimport { TaskQueryCloudRequestModel, TaskListRequestModel } from '../../../models/filter-cloud-model';\nimport { Observable, throwError } from 'rxjs';\nimport { TaskListCloudSortingModel } from '../../../models/task-list-sorting.model';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { TaskCloudNodePaging } from '../../../models/task-cloud.model';\nimport { map } from 'rxjs/operators';\nimport { TaskListCloudServiceInterface } from '../../../services/task-list-cloud.service.interface';\n\n@Injectable({ providedIn: 'root' })\nexport class TaskListCloudService extends BaseCloudService implements TaskListCloudServiceInterface {\n    /**\n     * Finds a task using an object with optional query properties.\n     *\n     * @deprecated From Activiti 8.7.0 forward, use TaskListCloudService.fetchTaskList instead.\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns Task information\n     */\n    getTaskByRequest(requestNode: TaskQueryCloudRequestModel, queryUrl?: string): Observable<any> {\n        if (requestNode.appName || requestNode.appName === '') {\n            queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/tasks`;\n            const queryParams = this.buildQueryParams(requestNode);\n            const sortingParams = this.buildSortingParam(requestNode.sorting);\n            if (sortingParams) {\n                queryParams['sort'] = sortingParams;\n            }\n            return this.get<TaskCloudNodePaging>(queryUrl, queryParams).pipe(\n                map((response) => {\n                    const entries = response.list?.entries;\n                    if (entries) {\n                        // TODO: this looks like a hack of the TaskCloudNodePaging collection\n                        response.list.entries = entries.map((entryData) => entryData.entry) as any;\n                    }\n                    return response;\n                })\n            );\n        } else {\n            return throwError('Appname not configured');\n        }\n    }\n\n    /**\n     * Available from Activiti version 8.7.0 onwards.\n     * Retrieves a list of tasks using an object with optional query properties.\n     *\n     * @param requestNode Query object\n     * @param queryUrl Query url\n     * @returns List of tasks\n     */\n    fetchTaskList(requestNode: TaskListRequestModel, queryUrl?: string): Observable<any> {\n        if (!requestNode?.appName) {\n            return throwError(() => new Error('Appname not configured'));\n        }\n\n        queryUrl = queryUrl || `${this.getBasePath(requestNode.appName)}/query/v1/tasks/search`;\n\n        const queryParams = {\n            maxItems: requestNode.pagination?.maxItems || 25,\n            skipCount: requestNode.pagination?.skipCount || 0\n        };\n\n        const queryData = this.buildQueryData(requestNode);\n\n        return this.post<any, TaskCloudNodePaging>(queryUrl, queryData, queryParams).pipe(\n            map((response) => {\n                const entries = response.list?.entries;\n                if (entries) {\n                    response.list.entries = entries.map((entryData) => entryData.entry) as any;\n                }\n                return response;\n            })\n        );\n    }\n\n    getTaskListCounter(requestNode: TaskListRequestModel): Observable<number> {\n        if (!requestNode.appName) {\n            return throwError(() => new Error('Appname not configured'));\n        }\n        return this.fetchTaskList(requestNode).pipe(map((tasks) => tasks.list.pagination.totalItems));\n    }\n\n    protected buildQueryData(requestNode: TaskListRequestModel) {\n        const queryData: any = {\n            id: requestNode.id,\n            parentId: requestNode.parentId,\n            processInstanceId: requestNode.processInstanceId,\n            status: requestNode.status,\n            processDefinitionName: requestNode.processDefinitionName,\n            processName: requestNode.processName,\n            assignee: requestNode.assignee,\n            priority: requestNode.priority,\n            name: requestNode.name,\n            completedBy: requestNode.completedBy,\n            completedFrom: requestNode.completedFrom,\n            completedTo: requestNode.completedTo,\n            createdFrom: requestNode.createdFrom,\n            createdTo: requestNode.createdTo,\n            dueDateFrom: requestNode.dueDateFrom,\n            dueDateTo: requestNode.dueDateTo,\n            processVariableKeys: requestNode.processVariableKeys,\n            processVariableFilters: requestNode.processVariableFilters\n        };\n\n        if (requestNode.sorting) {\n            queryData['sort'] = {\n                field: requestNode.sorting.orderBy,\n                direction: requestNode.sorting.direction.toLowerCase(),\n                isProcessVariable: requestNode.sorting.isFieldProcessVariable\n            };\n            if (queryData['sort'].isProcessVariable) {\n                queryData['sort'].processDefinitionKey = requestNode.sorting.processVariableData?.processDefinitionKey;\n                queryData['sort'].type = requestNode.sorting.processVariableData?.type;\n            }\n        }\n\n        /*\n         * Remove process variable filter keys with empty values from the query data.\n         */\n        if (queryData['processVariableFilters']) {\n            queryData['processVariableFilters'] = queryData['processVariableFilters'].filter(\n                (filter) => filter.value !== '' && filter.value !== null && filter.value !== undefined\n            );\n        }\n\n        /*\n         * Remove keys with empty values from the query data.\n         */\n        Object.keys(queryData).forEach((key) => {\n            const value = queryData[key];\n            const isValueEmpty = !value;\n            const isValueArrayWithEmptyValue = Array.isArray(value) && (value.length === 0 || value[0] === null);\n            if (isValueEmpty || isValueArrayWithEmptyValue) {\n                delete queryData[key];\n            }\n        });\n\n        return queryData;\n    }\n\n    protected buildQueryParams(requestNode: TaskQueryCloudRequestModel): any {\n        const queryParam: any = {};\n        for (const propertyKey in requestNode) {\n            if (\n                Object.prototype.hasOwnProperty.call(requestNode, propertyKey) &&\n                !this.isExcludedField(propertyKey) &&\n                this.isPropertyValueValid(requestNode, propertyKey)\n            ) {\n                if (propertyKey === 'variableKeys' && requestNode[propertyKey]?.length > 0) {\n                    queryParam[propertyKey] = requestNode[propertyKey].join(',');\n                } else {\n                    queryParam[propertyKey] = requestNode[propertyKey];\n                }\n            }\n        }\n        return queryParam;\n    }\n\n    protected isExcludedField(property: string): boolean {\n        return property === 'appName' || property === 'sorting';\n    }\n\n    protected isPropertyValueValid(requestNode: any, property: string): boolean {\n        return requestNode[property] !== '' && requestNode[property] !== null && requestNode[property] !== undefined;\n    }\n\n    protected buildSortingParam(models: TaskListCloudSortingModel[]): string {\n        let finalSorting: string = '';\n        if (models) {\n            for (const sort of models) {\n                if (!finalSorting) {\n                    finalSorting = `${sort.orderBy},${sort.direction}`;\n                } else {\n                    finalSorting = `${finalSorting}&${sort.orderBy},${sort.direction}`;\n                }\n            }\n        }\n        return encodeURI(finalSorting);\n    }\n}\n"]}

package/esm2022/lib/task/task-list/task-list-cloud.module.mjs

@@ -0,0 +1,57 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { TaskListCloudComponent } from './components/task-list/task-list-cloud.component';
+import { ServiceTaskListCloudComponent } from './components/service-task-list/service-task-list-cloud.component';
+import { TASK_LIST_CLOUD_TOKEN, TASK_LIST_PREFERENCES_SERVICE_TOKEN } from '../../services/cloud-token.service';
+import { TaskListCloudService } from './services/task-list-cloud.service';
+import { LocalPreferenceCloudService } from '../../services/local-preference-cloud.service';
+import * as i0 from "@angular/core";
+export const TASK_LIST_CLOUD_DIRECTIVES = [TaskListCloudComponent, ServiceTaskListCloudComponent];
+/** @deprecated use standalone components or TASK_LIST_CLOUD_DIRECTIVES instead */
+export class TaskListCloudModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudModule, imports: [TaskListCloudComponent, ServiceTaskListCloudComponent], exports: [TaskListCloudComponent, ServiceTaskListCloudComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudModule, providers: [
+            {
+                provide: TASK_LIST_CLOUD_TOKEN,
+                useClass: TaskListCloudService
+            },
+            {
+                provide: TASK_LIST_PREFERENCES_SERVICE_TOKEN,
+                useClass: LocalPreferenceCloudService
+            }
+        ], imports: [TASK_LIST_CLOUD_DIRECTIVES] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskListCloudModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...TASK_LIST_CLOUD_DIRECTIVES],
+                    exports: [...TASK_LIST_CLOUD_DIRECTIVES],
+                    providers: [
+                        {
+                            provide: TASK_LIST_CLOUD_TOKEN,
+                            useClass: TaskListCloudService
+                        },
+                        {
+                            provide: TASK_LIST_PREFERENCES_SERVICE_TOKEN,
+                            useClass: LocalPreferenceCloudService
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/types.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvcHJvY2Vzcy1zZXJ2aWNlcy1jbG91ZC9zcmMvbGliL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IHR5cGUgQ29tcG9uZW50U2VsZWN0aW9uTW9kZSA9ICdzaW5nbGUnIHwgJ211bHRpcGxlJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,40 @@
+/*!
+ * @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 './lib/process-services-cloud.module';
+export * from './lib/app/public-api';
+export * from './lib/process/public-api';
+export * from './lib/task/public-api';
+export * from './lib/group/public-api';
+export * from './lib/people/public-api';
+export * from './lib/form/public-api';
+export * from './lib/services/public-api';
+export * from './lib/rich-text-editor/public-api';
+export * from './lib/screen/public-api';
+export * from './lib/types';
+export * from './lib/common/index';
+export * from './lib/models/process-definition-cloud.model';
+export * from './lib/models/date-cloud-filter.model';
+export * from './lib/models/application-version.model';
+export * from './lib/models/engine-event-cloud.model';
+export * from './lib/models/task-cloud.model';
+export * from './lib/models/filter-cloud-model';
+export * from './lib/models/task-list-sorting.model';
+export * from './lib/models/process-instance-variable.model';
+export * from './lib/models/variable-definition';
+export * from './lib/models/date-format-cloud.model';
+export * from './lib/models/process-variable-filter.model';
+//# sourceMappingURL=data:application/json;base64,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