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

package/esm2022/lib/form/public-api.mjs

@@ -0,0 +1,44 @@
+/*!
+ * @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 './models/task-variable-cloud.model';
+export * from './components/spinner/form-spinner.component';
+export * from './components/form-cloud-custom-outcomes.component';
+export * from './components/form-cloud.component';
+export * from './components/form-definition-selector-cloud.component';
+export * from './components/cloud-form-rendering.service';
+export * from './components/widgets/attach-file/attach-file-cloud-widget.component';
+export * from './components/widgets/attach-file/file-properties-table/file-properties-table-cloud.component';
+export * from './components/widgets/upload/upload-cloud.widget';
+export * from './components/widgets/date/date-cloud.widget';
+export * from './components/widgets/dropdown/dropdown-cloud.widget';
+export * from './components/widgets/group/group-cloud.widget';
+export * from './components/widgets/people/people-cloud.widget';
+export * from './components/widgets/properties-viewer/properties-viewer.widget';
+export * from './components/widgets/properties-viewer/properties-viewer-wrapper/properties-viewer-wrapper.component';
+export * from './components/widgets/file-viewer/file-viewer.widget';
+export * from './components/widgets/display-rich-text/display-rich-text.widget';
+// widgets with schema
+export * from './components/widgets/radio-buttons/radio-buttons-cloud.widget';
+export * from './components/widgets/radio-buttons/radio-buttons-cloud.schema';
+export * from './services/content-cloud-node-selector.service';
+export * from './services/form-cloud.service';
+export * from './services/form-definition-selector-cloud.service';
+export * from './services/content-cloud-node-selector.service';
+export * from './services/process-cloud-content.service';
+export * from './services/display-mode.service';
+export * from './form-cloud.module';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/services/content-cloud-node-selector.service.mjs

@@ -0,0 +1,120 @@
+/*!
+ * @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 { NotificationService } from '@alfresco/adf-core';
+import { MatDialog } from '@angular/material/dialog';
+import { ContentNodeSelectorComponent, NodeAction, AlfrescoApiService } from '@alfresco/adf-content-services';
+import { NodesApi } from '@alfresco/js-api';
+import { from, Subject, throwError } from 'rxjs';
+import { catchError, map, mapTo } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-content-services";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/material/dialog";
+export class ContentCloudNodeSelectorService {
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    constructor(apiService, notificationService, dialog) {
+        this.apiService = apiService;
+        this.notificationService = notificationService;
+        this.dialog = dialog;
+        this.sourceNodeNotFound = false;
+    }
+    openUploadFileDialog(currentFolderId, selectionMode, isAllFileSources, restrictRootToCurrentFolderId) {
+        const select = new Subject();
+        select.subscribe({ complete: this.close.bind(this) });
+        const data = {
+            title: 'Select a file',
+            actionName: NodeAction.ATTACH,
+            currentFolderId,
+            restrictRootToCurrentFolderId,
+            select,
+            selectionMode,
+            isSelectionValid: (entry) => entry.isFile,
+            showFilesInResult: true,
+            showDropdownSiteList: false,
+            showLocalUploadButton: isAllFileSources
+        };
+        this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '66%');
+        return select;
+    }
+    async getNodeIdFromPath(destinationFolderPath) {
+        if (destinationFolderPath.alias && destinationFolderPath.path) {
+            try {
+                return await this.getNodeId(destinationFolderPath.alias, destinationFolderPath.path).toPromise();
+            }
+            catch {
+                /*empty*/
+            }
+        }
+        return this.getNodeId(destinationFolderPath.alias).toPromise();
+    }
+    async getNodeIdFromFolderVariableValue(variableValue, defaultAlias) {
+        const isExistingNode = await this.isExistingNode(variableValue);
+        return isExistingNode ? variableValue : this.getNodeId(defaultAlias).toPromise();
+    }
+    async isExistingNode(nodeId) {
+        let isExistingNode = false;
+        if (nodeId) {
+            try {
+                isExistingNode = await this.getNodeId(nodeId).pipe(mapTo(true)).toPromise();
+            }
+            catch {
+                /*empty*/
+            }
+        }
+        return isExistingNode;
+    }
+    getNodeId(nodeId, relativePath) {
+        let opts;
+        if (relativePath) {
+            opts = { relativePath };
+        }
+        return from(this.nodesApi.getNode(nodeId, opts)).pipe(map((nodeEntry) => nodeEntry.entry.id), catchError((error) => {
+            this.sourceNodeNotFound = true;
+            return this.handleError(error);
+        }));
+    }
+    openContentNodeDialog(data, currentPanelClass, chosenWidth) {
+        const contentNodeDialog = this.dialog.open(ContentNodeSelectorComponent, { data, panelClass: currentPanelClass, width: chosenWidth });
+        contentNodeDialog.afterOpened().subscribe(() => {
+            if (this.sourceNodeNotFound) {
+                this.notificationService.showWarning('ADF_CLOUD_TASK_FORM.ERROR.DESTINATION_FOLDER_PATH_ERROR');
+            }
+        });
+        contentNodeDialog.afterClosed().subscribe(() => {
+            this.sourceNodeNotFound = false;
+        });
+    }
+    close() {
+        this.dialog.closeAll();
+    }
+    handleError(error) {
+        return throwError(error || 'Server error');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentCloudNodeSelectorService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.NotificationService }, { token: i3.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentCloudNodeSelectorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentCloudNodeSelectorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.NotificationService }, { type: i3.MatDialog }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-cloud-node-selector.service.js","sourceRoot":"","sources":["../../../../../../../lib/process-services-cloud/src/lib/form/services/content-cloud-node-selector.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 { NotificationService } from '@alfresco/adf-core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { ContentNodeSelectorComponent, ContentNodeSelectorComponentData, NodeAction, AlfrescoApiService } from '@alfresco/adf-content-services';\nimport { Node, NodeEntry, NodesApi } from '@alfresco/js-api';\nimport { from, Observable, Subject, throwError } from 'rxjs';\nimport { catchError, map, mapTo } from 'rxjs/operators';\nimport { DestinationFolderPathModel } from '../models/form-cloud-representation.model';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ContentCloudNodeSelectorService {\n    private _nodesApi: NodesApi;\n    get nodesApi(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());\n        return this._nodesApi;\n    }\n\n    sourceNodeNotFound = false;\n\n    constructor(private apiService: AlfrescoApiService, private notificationService: NotificationService, private dialog: MatDialog) {}\n\n    openUploadFileDialog(\n        currentFolderId?: string,\n        selectionMode?: string,\n        isAllFileSources?: boolean,\n        restrictRootToCurrentFolderId?: boolean\n    ): Observable<Node[]> {\n        const select = new Subject<Node[]>();\n        select.subscribe({ complete: this.close.bind(this) });\n        const data = {\n            title: 'Select a file',\n            actionName: NodeAction.ATTACH,\n            currentFolderId,\n            restrictRootToCurrentFolderId,\n            select,\n            selectionMode,\n            isSelectionValid: (entry: Node) => entry.isFile,\n            showFilesInResult: true,\n            showDropdownSiteList: false,\n            showLocalUploadButton: isAllFileSources\n        } as ContentNodeSelectorComponentData;\n        this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '66%');\n        return select;\n    }\n\n    async getNodeIdFromPath(destinationFolderPath: DestinationFolderPathModel): Promise<string> {\n        if (destinationFolderPath.alias && destinationFolderPath.path) {\n            try {\n                return await this.getNodeId(destinationFolderPath.alias, destinationFolderPath.path).toPromise();\n            } catch {\n                /*empty*/\n            }\n        }\n\n        return this.getNodeId(destinationFolderPath.alias).toPromise();\n    }\n\n    async getNodeIdFromFolderVariableValue(variableValue: string, defaultAlias?: string): Promise<string> {\n        const isExistingNode = await this.isExistingNode(variableValue);\n        return isExistingNode ? variableValue : this.getNodeId(defaultAlias).toPromise();\n    }\n\n    async isExistingNode(nodeId: string): Promise<boolean> {\n        let isExistingNode = false;\n        if (nodeId) {\n            try {\n                isExistingNode = await this.getNodeId(nodeId).pipe(mapTo(true)).toPromise();\n            } catch {\n                /*empty*/\n            }\n        }\n        return isExistingNode;\n    }\n\n    private getNodeId(nodeId: string, relativePath?: string): Observable<string> {\n        let opts: any;\n        if (relativePath) {\n            opts = { relativePath };\n        }\n        return from(this.nodesApi.getNode(nodeId, opts)).pipe(\n            map((nodeEntry: NodeEntry) => nodeEntry.entry.id),\n            catchError((error) => {\n                this.sourceNodeNotFound = true;\n                return this.handleError(error);\n            })\n        );\n    }\n\n    private openContentNodeDialog(data: ContentNodeSelectorComponentData, currentPanelClass: string, chosenWidth: string) {\n        const contentNodeDialog = this.dialog.open(ContentNodeSelectorComponent, { data, panelClass: currentPanelClass, width: chosenWidth });\n        contentNodeDialog.afterOpened().subscribe(() => {\n            if (this.sourceNodeNotFound) {\n                this.notificationService.showWarning('ADF_CLOUD_TASK_FORM.ERROR.DESTINATION_FOLDER_PATH_ERROR');\n            }\n        });\n        contentNodeDialog.afterClosed().subscribe(() => {\n            this.sourceNodeNotFound = false;\n        });\n    }\n\n    close() {\n        this.dialog.closeAll();\n    }\n\n    private handleError(error: any): Observable<any> {\n        return throwError(error || 'Server error');\n    }\n}\n"]}

package/esm2022/lib/form/services/display-mode.service.mjs

@@ -0,0 +1,146 @@
+/*!
+ * @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 { Subject } from 'rxjs';
+import { FormCloudDisplayMode } from '../../services/form-fields.interfaces';
+import * as i0 from "@angular/core";
+export class DisplayModeService {
+    static { this.DEFAULT_DISPLAY_MODE_CONFIGURATIONS = [
+        {
+            displayMode: FormCloudDisplayMode.inline,
+            default: true
+        }
+    ]; }
+    static { this.IMPLEMENTED_DISPLAY_MODE_CONFIGURATIONS = [
+        ...DisplayModeService.DEFAULT_DISPLAY_MODE_CONFIGURATIONS,
+        {
+            displayMode: FormCloudDisplayMode.fullScreen,
+            options: {
+                onDisplayModeOn: () => { },
+                onDisplayModeOff: (id) => DisplayModeService.changeDisplayMode({ displayMode: FormCloudDisplayMode.inline, id }),
+                onCompleteTask: (id) => DisplayModeService.changeDisplayMode({ displayMode: FormCloudDisplayMode.inline, id }),
+                onSaveTask: () => { },
+                fullscreen: true,
+                displayToolbar: true,
+                displayCloseButton: true,
+                trapFocus: true
+            }
+        },
+        {
+            displayMode: FormCloudDisplayMode.standalone,
+            options: {
+                onDisplayModeOn: () => { },
+                onDisplayModeOff: () => { },
+                onCompleteTask: () => { },
+                onSaveTask: () => { },
+                fullscreen: true,
+                displayToolbar: false,
+                trapFocus: true
+            }
+        }
+    ]; }
+    static { this.DEFAULT_DISPLAY_MODE = FormCloudDisplayMode.inline; }
+    static { this.displayMode = new Subject(); }
+    static { this.displayMode$ = DisplayModeService.displayMode.asObservable(); }
+    static changeDisplayMode(change) {
+        DisplayModeService.displayMode.next(change);
+    }
+    getDefaultDisplayModeConfigurations() {
+        return DisplayModeService.DEFAULT_DISPLAY_MODE_CONFIGURATIONS;
+    }
+    getDisplayModeConfigurations(availableConfigurations) {
+        if (availableConfigurations && availableConfigurations.length > 0) {
+            return availableConfigurations;
+        }
+        else {
+            return this.getDefaultDisplayModeConfigurations();
+        }
+    }
+    getDisplayMode(displayMode, availableConfigurations) {
+        const configuration = this.findConfiguration(displayMode, availableConfigurations);
+        if (configuration) {
+            return configuration.displayMode;
+        }
+        else if (availableConfigurations && availableConfigurations.length > 0) {
+            return availableConfigurations.length === 1
+                ? availableConfigurations[0].displayMode
+                : availableConfigurations.find((config) => config.default)?.displayMode || availableConfigurations[0].displayMode;
+        }
+        else {
+            return DisplayModeService.DEFAULT_DISPLAY_MODE;
+        }
+    }
+    findConfiguration(displayMode, availableConfigurations) {
+        return this.getDisplayModeConfigurations(availableConfigurations).find((config) => config.displayMode === displayMode);
+    }
+    onCompleteTask(id, displayMode, availableConfigurations) {
+        const configuration = this.findConfiguration(displayMode, availableConfigurations);
+        if (configuration?.options?.onCompleteTask) {
+            configuration.options.onCompleteTask(id);
+        }
+    }
+    onSaveTask(id, displayMode, availableConfigurations) {
+        const configuration = this.findConfiguration(displayMode, availableConfigurations);
+        if (configuration?.options?.onSaveTask) {
+            configuration.options.onSaveTask(id);
+        }
+    }
+    onDisplayModeOff(id, displayMode, availableConfigurations) {
+        const configuration = this.findConfiguration(displayMode, availableConfigurations);
+        if (configuration?.options?.onDisplayModeOff) {
+            configuration.options.onDisplayModeOff(id);
+        }
+    }
+    onDisplayModeOn(id, displayMode, availableConfigurations) {
+        const configuration = this.findConfiguration(displayMode, availableConfigurations);
+        if (configuration?.options?.onDisplayModeOn) {
+            configuration.options.onDisplayModeOn(id);
+        }
+    }
+    switchToDisplayMode(id, newDisplayMode, oldDisplayMode, availableConfigurations) {
+        const oldConfiguration = this.findConfiguration(oldDisplayMode, availableConfigurations);
+        const newConfiguration = this.findConfiguration(newDisplayMode, availableConfigurations);
+        if (oldConfiguration?.displayMode !== newConfiguration?.displayMode) {
+            if (oldConfiguration) {
+                this.onDisplayModeOff(id, oldDisplayMode, availableConfigurations);
+            }
+            if (newConfiguration) {
+                DisplayModeService.changeDisplayMode({ id, displayMode: newConfiguration.displayMode });
+                this.onDisplayModeOn(id, newDisplayMode, availableConfigurations);
+                return newConfiguration.displayMode;
+            }
+            else {
+                const displayMode = this.getDisplayMode(newDisplayMode, availableConfigurations);
+                DisplayModeService.changeDisplayMode({ id, displayMode });
+                this.onDisplayModeOn(id, displayMode, availableConfigurations);
+                return displayMode;
+            }
+        }
+        else {
+            return oldConfiguration?.displayMode || this.getDisplayMode(oldDisplayMode, availableConfigurations);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisplayModeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisplayModeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisplayModeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-mode.service.js","sourceRoot":"","sources":["../../../../../../../lib/process-services-cloud/src/lib/form/services/display-mode.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 { Observable, Subject } from 'rxjs';\nimport { FormCloudDisplayMode, FormCloudDisplayModeChange, FormCloudDisplayModeConfiguration } from '../../services/form-fields.interfaces';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class DisplayModeService {\n    public static readonly DEFAULT_DISPLAY_MODE_CONFIGURATIONS: FormCloudDisplayModeConfiguration[] = [\n        {\n            displayMode: FormCloudDisplayMode.inline,\n            default: true\n        }\n    ];\n\n    public static readonly IMPLEMENTED_DISPLAY_MODE_CONFIGURATIONS: FormCloudDisplayModeConfiguration[] = [\n        ...DisplayModeService.DEFAULT_DISPLAY_MODE_CONFIGURATIONS,\n        {\n            displayMode: FormCloudDisplayMode.fullScreen,\n            options: {\n                onDisplayModeOn: () => {},\n                onDisplayModeOff: (id: string) => DisplayModeService.changeDisplayMode({ displayMode: FormCloudDisplayMode.inline, id }),\n                onCompleteTask: (id: string) => DisplayModeService.changeDisplayMode({ displayMode: FormCloudDisplayMode.inline, id }),\n                onSaveTask: () => {},\n                fullscreen: true,\n                displayToolbar: true,\n                displayCloseButton: true,\n                trapFocus: true\n            }\n        },\n        {\n            displayMode: FormCloudDisplayMode.standalone,\n            options: {\n                onDisplayModeOn: () => {},\n                onDisplayModeOff: () => {},\n                onCompleteTask: () => {},\n                onSaveTask: () => {},\n                fullscreen: true,\n                displayToolbar: false,\n                trapFocus: true\n            }\n        }\n    ];\n\n    public static readonly DEFAULT_DISPLAY_MODE: FormCloudDisplayMode = FormCloudDisplayMode.inline;\n\n    private static readonly displayMode = new Subject<FormCloudDisplayModeChange>();\n\n    static readonly displayMode$: Observable<FormCloudDisplayModeChange> = DisplayModeService.displayMode.asObservable();\n\n    static changeDisplayMode(change: FormCloudDisplayModeChange) {\n        DisplayModeService.displayMode.next(change);\n    }\n\n    getDefaultDisplayModeConfigurations(): FormCloudDisplayModeConfiguration[] {\n        return DisplayModeService.DEFAULT_DISPLAY_MODE_CONFIGURATIONS;\n    }\n\n    getDisplayModeConfigurations(availableConfigurations?: FormCloudDisplayModeConfiguration[]): FormCloudDisplayModeConfiguration[] {\n        if (availableConfigurations && availableConfigurations.length > 0) {\n            return availableConfigurations;\n        } else {\n            return this.getDefaultDisplayModeConfigurations();\n        }\n    }\n\n    getDisplayMode(displayMode?: string, availableConfigurations?: FormCloudDisplayModeConfiguration[]): string {\n        const configuration = this.findConfiguration(displayMode, availableConfigurations);\n\n        if (configuration) {\n            return configuration.displayMode;\n        } else if (availableConfigurations && availableConfigurations.length > 0) {\n            return availableConfigurations.length === 1\n                ? availableConfigurations[0].displayMode\n                : availableConfigurations.find((config) => config.default)?.displayMode || availableConfigurations[0].displayMode;\n        } else {\n            return DisplayModeService.DEFAULT_DISPLAY_MODE;\n        }\n    }\n\n    findConfiguration(displayMode?: string, availableConfigurations?: FormCloudDisplayModeConfiguration[]): FormCloudDisplayModeConfiguration {\n        return this.getDisplayModeConfigurations(availableConfigurations).find((config) => config.displayMode === displayMode);\n    }\n\n    onCompleteTask(id?: string, displayMode?: string, availableConfigurations?: FormCloudDisplayModeConfiguration[]) {\n        const configuration = this.findConfiguration(displayMode, availableConfigurations);\n\n        if (configuration?.options?.onCompleteTask) {\n            configuration.options.onCompleteTask(id);\n        }\n    }\n\n    onSaveTask(id?: string, displayMode?: string, availableConfigurations?: FormCloudDisplayModeConfiguration[]) {\n        const configuration = this.findConfiguration(displayMode, availableConfigurations);\n\n        if (configuration?.options?.onSaveTask) {\n            configuration.options.onSaveTask(id);\n        }\n    }\n\n    onDisplayModeOff(id?: string, displayMode?: string, availableConfigurations?: FormCloudDisplayModeConfiguration[]) {\n        const configuration = this.findConfiguration(displayMode, availableConfigurations);\n\n        if (configuration?.options?.onDisplayModeOff) {\n            configuration.options.onDisplayModeOff(id);\n        }\n    }\n\n    onDisplayModeOn(id?: string, displayMode?: string, availableConfigurations?: FormCloudDisplayModeConfiguration[]) {\n        const configuration = this.findConfiguration(displayMode, availableConfigurations);\n\n        if (configuration?.options?.onDisplayModeOn) {\n            configuration.options.onDisplayModeOn(id);\n        }\n    }\n\n    switchToDisplayMode(\n        id?: string,\n        newDisplayMode?: string,\n        oldDisplayMode?: string,\n        availableConfigurations?: FormCloudDisplayModeConfiguration[]\n    ): string {\n        const oldConfiguration = this.findConfiguration(oldDisplayMode, availableConfigurations);\n        const newConfiguration = this.findConfiguration(newDisplayMode, availableConfigurations);\n\n        if (oldConfiguration?.displayMode !== newConfiguration?.displayMode) {\n            if (oldConfiguration) {\n                this.onDisplayModeOff(id, oldDisplayMode, availableConfigurations);\n            }\n\n            if (newConfiguration) {\n                DisplayModeService.changeDisplayMode({ id, displayMode: newConfiguration.displayMode });\n                this.onDisplayModeOn(id, newDisplayMode, availableConfigurations);\n                return newConfiguration.displayMode;\n            } else {\n                const displayMode = this.getDisplayMode(newDisplayMode, availableConfigurations);\n                DisplayModeService.changeDisplayMode({ id, displayMode });\n                this.onDisplayModeOn(id, displayMode, availableConfigurations);\n                return displayMode;\n            }\n        } else {\n            return oldConfiguration?.displayMode || this.getDisplayMode(oldDisplayMode, availableConfigurations);\n        }\n    }\n}\n"]}

package/esm2022/lib/form/services/form-cloud.service.interface.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/form/services/form-cloud.service.mjs

@@ -0,0 +1,201 @@
+/*!
+ * @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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { FormModel } from '@alfresco/adf-core';
+import { from, EMPTY } from 'rxjs';
+import { expand, map, reduce, switchMap } from 'rxjs/operators';
+import { UploadApi } from '@alfresco/js-api';
+import { TaskVariableCloud } from '../models/task-variable-cloud.model';
+import { BaseCloudService } from '../../services/base-cloud.service';
+import { AdfHttpClient } from '@alfresco/adf-core/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core/api";
+export const FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN = new InjectionToken('FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN');
+export class FormCloudService extends BaseCloudService {
+    get uploadApi() {
+        this._uploadApi = this._uploadApi ?? new UploadApi(this.apiService.getInstance());
+        return this._uploadApi;
+    }
+    constructor(adfHttpClient, injectedFieldValidators) {
+        super(adfHttpClient);
+        this.fieldValidators = injectedFieldValidators || [];
+    }
+    /**
+     * Gets the form definition of a task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the target task
+     * @param version Version of the form
+     * @returns Form definition
+     */
+    getTaskForm(appName, taskId, version) {
+        return this.getTask(appName, taskId).pipe(switchMap((task) => this.getForm(appName, task.formKey, version).pipe(map((form) => {
+            const flattenForm = {
+                ...form.formRepresentation,
+                ...form.formRepresentation.formDefinition,
+                taskId: task.id,
+                taskName: task.name,
+                processDefinitionId: task.processDefinitionId,
+                processInstanceId: task.processInstanceId
+            };
+            delete flattenForm.formDefinition;
+            return flattenForm;
+        }))));
+    }
+    /**
+     * Saves a task form.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the target task
+     * @param processInstanceId ID of processInstance
+     * @param formId ID of the form to save
+     * @param values Form values object
+     * @returns Updated task details
+     */
+    saveTaskForm(appName, taskId, processInstanceId, formId, values) {
+        const apiUrl = `${this.getBasePath(appName)}/form/v1/forms/${formId}/save`;
+        const saveFormRepresentation = {
+            values,
+            taskId,
+            processInstanceId
+        };
+        return this.post(apiUrl, saveFormRepresentation).pipe(map((res) => res.entry));
+    }
+    createTemporaryRawRelatedContent(file, nodeId, contentHost) {
+        const changedConfig = this.apiService.lastConfig;
+        changedConfig.provider = 'ALL';
+        changedConfig.hostEcm = contentHost.replace('/alfresco', '');
+        this.apiService.getInstance().setConfig(changedConfig);
+        return from(this.uploadApi.uploadFile(file, '', nodeId, null, { overwrite: true })).pipe(map((res) => res.entry));
+    }
+    /**
+     * Completes a task form.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the target task
+     * @param processInstanceId ID of processInstance
+     * @param formId ID of the form to complete
+     * @param formValues Form values object
+     * @param outcome Form outcome
+     * @param version of the form
+     * @returns Updated task details
+     */
+    completeTaskForm(appName, taskId, processInstanceId, formId, formValues, outcome, version) {
+        const apiUrl = `${this.getBasePath(appName)}/form/v1/forms/${formId}/submit/versions/${version}`;
+        const completeFormRepresentation = {
+            values: formValues,
+            taskId,
+            processInstanceId
+        };
+        if (outcome) {
+            completeFormRepresentation.outcome = outcome;
+        }
+        return this.post(apiUrl, completeFormRepresentation).pipe(map((res) => res.entry));
+    }
+    /**
+     * Gets details of a task
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the target task
+     * @returns Details of the task
+     */
+    getTask(appName, taskId) {
+        const apiUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}`;
+        return this.get(apiUrl).pipe(map((res) => res.entry));
+    }
+    /**
+     * Gets the variables of a task.
+     *
+     * @param appName Name of the app
+     * @param taskId ID of the target task
+     * @returns Task variables
+     */
+    getTaskVariables(appName, taskId) {
+        const apiUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}/variables`;
+        let skipCount = 0;
+        const maxItems = 1000;
+        return this.get(apiUrl, { maxItems, skipCount }).pipe(expand((res) => {
+            skipCount += maxItems;
+            return res.list.pagination.hasMoreItems
+                ? this.get(apiUrl, {
+                    maxItems,
+                    skipCount
+                })
+                : EMPTY;
+        }), map((res) => res.list.entries.map((variable) => new TaskVariableCloud(variable.entry))), reduce((acc, res) => acc.concat(res), []));
+    }
+    /**
+     * Gets a form definition.
+     *
+     * @param appName Name of the app
+     * @param formKey key of the target task
+     * @param version Version of the form
+     * @returns Form definition
+     */
+    getForm(appName, formKey, version) {
+        let url = `${this.getBasePath(appName)}/form/v1/forms/${formKey}`;
+        if (version) {
+            url += `/versions/${version}`;
+        }
+        return this.get(url);
+    }
+    getRestWidgetData(formName, widgetId, body = {}) {
+        const appName = this.appConfigService.get('alfresco-deployed-apps')[0]?.name;
+        const apiUrl = `${this.getBasePath(appName)}/form/v1/forms/${formName}/values/${widgetId}`;
+        return this.post(apiUrl, body);
+    }
+    /**
+     * Parses JSON data to create a corresponding form.
+     *
+     * @param json JSON data to create the form
+     * @param data Values for the form's fields
+     * @param readOnly Toggles whether or not the form should be read-only
+     * @returns Form created from the JSON specification
+     */
+    parseForm(json, data, readOnly = false) {
+        if (json) {
+            const flattenForm = {
+                ...json.formRepresentation,
+                ...json.formRepresentation.formDefinition
+            };
+            delete flattenForm.formDefinition;
+            const formValues = {};
+            (data || []).forEach((variable) => {
+                formValues[variable.name] = variable.value;
+            });
+            return new FormModel(flattenForm, formValues, readOnly, undefined, undefined, this.fieldValidators);
+        }
+        return null;
+    }
+    getPreviewState() {
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormCloudService, deps: [{ token: i1.AdfHttpClient }, { token: FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormCloudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AdfHttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-cloud.service.js","sourceRoot":"","sources":["../../../../../../../lib/process-services-cloud/src/lib/form/services/form-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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { FormValues, FormModel, FormFieldOption, FormFieldValidator } from '@alfresco/adf-core';\nimport { Observable, from, EMPTY } from 'rxjs';\nimport { expand, map, reduce, switchMap } from 'rxjs/operators';\nimport { TaskDetailsCloudModel } from '../../task/models/task-details-cloud.model';\nimport { CompleteFormRepresentation, UploadApi } from '@alfresco/js-api';\nimport { TaskVariableCloud } from '../models/task-variable-cloud.model';\nimport { BaseCloudService } from '../../services/base-cloud.service';\nimport { FormContent } from '../../services/form-fields.interfaces';\nimport { FormCloudServiceInterface } from './form-cloud.service.interface';\nimport { AdfHttpClient } from '@alfresco/adf-core/api';\n\nexport const FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN = new InjectionToken<FormFieldValidator[]>('FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN');\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FormCloudService extends BaseCloudService implements FormCloudServiceInterface {\n    private _uploadApi: UploadApi;\n    private fieldValidators: FormFieldValidator[];\n    get uploadApi(): UploadApi {\n        this._uploadApi = this._uploadApi ?? new UploadApi(this.apiService.getInstance());\n        return this._uploadApi;\n    }\n\n    constructor(\n        adfHttpClient: AdfHttpClient,\n        @Optional() @Inject(FORM_CLOUD_SERVICE_FIELD_VALIDATORS_TOKEN) injectedFieldValidators?: FormFieldValidator[]\n    ) {\n        super(adfHttpClient);\n        this.fieldValidators = injectedFieldValidators || [];\n    }\n\n    /**\n     * Gets the form definition of a task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the target task\n     * @param version Version of the form\n     * @returns Form definition\n     */\n    getTaskForm(appName: string, taskId: string, version?: number): Observable<any> {\n        return this.getTask(appName, taskId).pipe(\n            switchMap((task) =>\n                this.getForm(appName, task.formKey, version).pipe(\n                    map((form: FormContent) => {\n                        const flattenForm = {\n                            ...form.formRepresentation,\n                            ...form.formRepresentation.formDefinition,\n                            taskId: task.id,\n                            taskName: task.name,\n                            processDefinitionId: task.processDefinitionId,\n                            processInstanceId: task.processInstanceId\n                        };\n                        delete flattenForm.formDefinition;\n                        return flattenForm;\n                    })\n                )\n            )\n        );\n    }\n\n    /**\n     * Saves a task form.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the target task\n     * @param processInstanceId ID of processInstance\n     * @param formId ID of the form to save\n     * @param values Form values object\n     * @returns Updated task details\n     */\n    saveTaskForm(appName: string, taskId: string, processInstanceId: string, formId: string, values: FormValues): Observable<TaskDetailsCloudModel> {\n        const apiUrl = `${this.getBasePath(appName)}/form/v1/forms/${formId}/save`;\n        const saveFormRepresentation: any = {\n            values,\n            taskId,\n            processInstanceId\n        };\n\n        return this.post(apiUrl, saveFormRepresentation).pipe(map((res: any) => res.entry));\n    }\n\n    createTemporaryRawRelatedContent(file: any, nodeId: string, contentHost: string): Observable<any> {\n        const changedConfig = this.apiService.lastConfig;\n        changedConfig.provider = 'ALL';\n        changedConfig.hostEcm = contentHost.replace('/alfresco', '');\n        this.apiService.getInstance().setConfig(changedConfig);\n        return from(this.uploadApi.uploadFile(file, '', nodeId, null, { overwrite: true })).pipe(map((res: any) => res.entry));\n    }\n\n    /**\n     * Completes a task form.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the target task\n     * @param processInstanceId ID of processInstance\n     * @param formId ID of the form to complete\n     * @param formValues Form values object\n     * @param outcome Form outcome\n     * @param version of the form\n     * @returns Updated task details\n     */\n    completeTaskForm(\n        appName: string,\n        taskId: string,\n        processInstanceId: string,\n        formId: string,\n        formValues: FormValues,\n        outcome: string,\n        version: number\n    ): Observable<TaskDetailsCloudModel> {\n        const apiUrl = `${this.getBasePath(appName)}/form/v1/forms/${formId}/submit/versions/${version}`;\n        const completeFormRepresentation = {\n            values: formValues,\n            taskId,\n            processInstanceId\n        } as CompleteFormRepresentation;\n\n        if (outcome) {\n            completeFormRepresentation.outcome = outcome;\n        }\n\n        return this.post(apiUrl, completeFormRepresentation).pipe(map((res: any) => res.entry));\n    }\n\n    /**\n     * Gets details of a task\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the target task\n     * @returns Details of the task\n     */\n    getTask(appName: string, taskId: string): Observable<TaskDetailsCloudModel> {\n        const apiUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}`;\n\n        return this.get(apiUrl).pipe(map((res: any) => res.entry));\n    }\n\n    /**\n     * Gets the variables of a task.\n     *\n     * @param appName Name of the app\n     * @param taskId ID of the target task\n     * @returns Task variables\n     */\n    getTaskVariables(appName: string, taskId: string): Observable<TaskVariableCloud[]> {\n        const apiUrl = `${this.getBasePath(appName)}/query/v1/tasks/${taskId}/variables`;\n        let skipCount = 0;\n        const maxItems = 1000;\n\n        return this.get(apiUrl, { maxItems, skipCount }).pipe(\n            expand((res: any) => {\n                skipCount += maxItems;\n                return res.list.pagination.hasMoreItems\n                    ? this.get(apiUrl, {\n                          maxItems,\n                          skipCount\n                      })\n                    : EMPTY;\n            }),\n            map((res: any) => res.list.entries.map((variable) => new TaskVariableCloud(variable.entry))),\n            reduce((acc, res) => acc.concat(res), [])\n        );\n    }\n\n    /**\n     * Gets a form definition.\n     *\n     * @param appName Name of the app\n     * @param formKey key of the target task\n     * @param version Version of the form\n     * @returns Form definition\n     */\n    getForm(appName: string, formKey: string, version?: number): Observable<FormContent> {\n        let url = `${this.getBasePath(appName)}/form/v1/forms/${formKey}`;\n\n        if (version) {\n            url += `/versions/${version}`;\n        }\n\n        return this.get(url);\n    }\n\n    getRestWidgetData(formName: string, widgetId: string, body: any = {}): Observable<FormFieldOption[]> {\n        const appName = this.appConfigService.get('alfresco-deployed-apps')[0]?.name;\n        const apiUrl = `${this.getBasePath(appName)}/form/v1/forms/${formName}/values/${widgetId}`;\n        return this.post(apiUrl, body);\n    }\n\n    /**\n     * Parses JSON data to create a corresponding form.\n     *\n     * @param json JSON data to create the form\n     * @param data Values for the form's fields\n     * @param readOnly Toggles whether or not the form should be read-only\n     * @returns Form created from the JSON specification\n     */\n    parseForm(json: any, data?: TaskVariableCloud[], readOnly: boolean = false): FormModel {\n        if (json) {\n            const flattenForm = {\n                ...json.formRepresentation,\n                ...json.formRepresentation.formDefinition\n            };\n            delete flattenForm.formDefinition;\n\n            const formValues: FormValues = {};\n            (data || []).forEach((variable) => {\n                formValues[variable.name] = variable.value;\n            });\n\n            return new FormModel(flattenForm, formValues, readOnly, undefined, undefined, this.fieldValidators);\n        }\n        return null;\n    }\n\n    getPreviewState(): boolean {\n        return false;\n    }\n}\n"]}