@alfresco/adf-content-services 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/permission-manager/services/node-permission.service.mjs

@@ -0,0 +1,299 @@
+/*!
+ * @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 { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { TranslationService } from '@alfresco/adf-core';
+import { NodesApiService } from '../../common/services/nodes-api.service';
+import { EcmUserModel } from '../../common/models/ecm-user.model';
+import { GroupsApi } from '@alfresco/js-api';
+import { SearchService } from '../../search/services/search.service';
+import { Injectable } from '@angular/core';
+import { forkJoin, from, of, throwError } from 'rxjs';
+import { catchError, map, switchMap } from 'rxjs/operators';
+import { PermissionDisplayModel } from '../models/permission.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "../../search/services/search.service";
+import * as i3 from "../../common/services/nodes-api.service";
+import * as i4 from "@alfresco/adf-core";
+export class NodePermissionService {
+    get groupsApi() {
+        this._groupsApi = this._groupsApi ?? new GroupsApi(this.apiService.getInstance());
+        return this._groupsApi;
+    }
+    constructor(apiService, searchApiService, nodeService, translation) {
+        this.apiService = apiService;
+        this.searchApiService = searchApiService;
+        this.nodeService = nodeService;
+        this.translation = translation;
+    }
+    /**
+     * Gets a list of roles for the current node.
+     *
+     * @param node The target node
+     * @returns Array of strings representing the roles
+     */
+    getNodeRoles(node) {
+        if (node.path.elements.some((el) => el.nodeType === 'st:site' || el.nodeType === 'st:sites')) {
+            const searchRequest = this.buildRetrieveSiteQueryBody(node.path.elements);
+            return this.searchApiService.searchByQueryBody(searchRequest).pipe(switchMap((siteNodeList) => {
+                const siteName = siteNodeList.list.entries[0].entry.name;
+                return this.getGroupMembersBySiteName(siteName);
+            }));
+        }
+        else {
+            return of(node.permissions?.settable);
+        }
+    }
+    /**
+     * Get permissions for a given node
+     *
+     * @param node Node to check permissions for
+     * @returns list of permission models
+     */
+    getNodePermissions(node) {
+        const result = [];
+        if (node?.permissions?.locallySet) {
+            node.permissions.locallySet.map((permissionElement) => {
+                result.push(new PermissionDisplayModel(permissionElement));
+            });
+        }
+        if (node?.permissions?.inherited) {
+            node.permissions.inherited.map((permissionElement) => {
+                const permissionInherited = new PermissionDisplayModel(permissionElement);
+                permissionInherited.isInherited = true;
+                result.push(permissionInherited);
+            });
+        }
+        return result;
+    }
+    /**
+     * Updates the permission role for a node.
+     *
+     * @param node Target node
+     * @param updatedPermissionRole Permission role to update or add
+     * @returns Node with updated permission
+     */
+    updatePermissionRole(node, updatedPermissionRole) {
+        const permissionBody = { permissions: { locallySet: [] } };
+        const index = node.permissions.locallySet.map((permission) => permission.authorityId).indexOf(updatedPermissionRole.authorityId);
+        permissionBody.permissions.locallySet = permissionBody.permissions.locallySet.concat(node.permissions.locallySet);
+        if (index !== -1) {
+            permissionBody.permissions.locallySet[index] = updatedPermissionRole;
+        }
+        else {
+            permissionBody.permissions.locallySet.push(updatedPermissionRole);
+        }
+        return this.nodeService.updateNode(node.id, permissionBody);
+    }
+    /**
+     * Update permissions for a node.
+     *
+     * @param nodeId ID of the target node
+     * @param permissionList New permission settings
+     * @returns Node with updated permissions
+     */
+    updateNodePermissions(nodeId, permissionList) {
+        return this.nodeService.getNode(nodeId).pipe(switchMap((node) => this.updateLocallySetPermissions(node, permissionList)));
+    }
+    /**
+     * Updates the locally set permissions for a node.
+     *
+     * @param node ID of the target node
+     * @param permissions Permission settings
+     * @returns Node with updated permissions
+     */
+    updateLocallySetPermissions(node, permissions) {
+        const permissionBody = { permissions: { locallySet: [] } };
+        const permissionList = permissions;
+        const duplicatedPermissions = this.getDuplicatedPermissions(node.permissions.locallySet, permissionList);
+        if (duplicatedPermissions.length > 0) {
+            const list = duplicatedPermissions
+                .map((permission) => 'authority -> ' + permission.authorityId + ' / role -> ' + permission.name)
+                .join(', ');
+            const duplicatePermissionMessage = this.translation.instant('PERMISSION_MANAGER.ERROR.DUPLICATE-PERMISSION', { list });
+            return throwError(duplicatePermissionMessage);
+        }
+        permissionBody.permissions.locallySet = node.permissions.locallySet ? node.permissions.locallySet.concat(permissionList) : permissionList;
+        return this.nodeService.updateNode(node.id, permissionBody);
+    }
+    getDuplicatedPermissions(nodeLocallySet, permissionListAdded) {
+        const duplicatePermissions = [];
+        if (nodeLocallySet) {
+            permissionListAdded.forEach((permission) => {
+                const duplicate = nodeLocallySet.find((localPermission) => this.isEqualPermission(localPermission, permission));
+                if (duplicate) {
+                    duplicatePermissions.push(duplicate);
+                }
+            });
+        }
+        return duplicatePermissions;
+    }
+    isEqualPermission(oldPermission, newPermission) {
+        return (oldPermission.accessStatus === newPermission.accessStatus &&
+            oldPermission.authorityId === newPermission.authorityId &&
+            oldPermission.name === newPermission.name);
+    }
+    /**
+     * Removes a permission setting from a node.
+     *
+     * @param node ID of the target node
+     * @param permissionToRemove Permission setting to remove
+     * @returns Node with modified permissions
+     */
+    removePermission(node, permissionToRemove) {
+        const permissionBody = { permissions: { locallySet: [] } };
+        const index = node.permissions.locallySet.map((permission) => permission.authorityId).indexOf(permissionToRemove.authorityId);
+        if (index !== -1) {
+            node.permissions.locallySet.splice(index, 1);
+            permissionBody.permissions.locallySet = node.permissions.locallySet;
+            return this.nodeService.updateNode(node.id, permissionBody);
+        }
+        else {
+            return of(node);
+        }
+    }
+    getGroupMembersBySiteName(siteName) {
+        const groupName = 'GROUP_site_' + siteName;
+        return this.getGroupMemberByGroupName(groupName).pipe(map((groupMemberPaging) => {
+            const displayResult = [];
+            groupMemberPaging.list.entries.forEach((member) => {
+                displayResult.push(this.formattedRoleName(member.entry.displayName, 'site_' + siteName));
+            });
+            return displayResult;
+        }));
+    }
+    /**
+     * Gets all members related to a group name.
+     *
+     * @param groupName Name of group to look for members
+     * @param opts Extra options supported by JS-API
+     * @returns List of members
+     */
+    getGroupMemberByGroupName(groupName, opts) {
+        return from(this.groupsApi.listGroupMemberships(groupName, opts));
+    }
+    formattedRoleName(displayName, siteName) {
+        return displayName.replace(siteName + '_', '');
+    }
+    buildRetrieveSiteQueryBody(nodePath) {
+        const pathNames = nodePath.map((node) => 'name: "' + node.name + '"');
+        const builtPathNames = pathNames.join(' OR ');
+        return {
+            query: {
+                query: builtPathNames
+            },
+            paging: {
+                maxItems: 100,
+                skipCount: 0
+            },
+            include: ['aspectNames', 'properties'],
+            filterQueries: [
+                {
+                    query: `TYPE:'st:site'`
+                }
+            ]
+        };
+    }
+    getLocalPermissions(node) {
+        const result = [];
+        if (node?.permissions?.locallySet) {
+            node.permissions.locallySet.forEach((permissionElement) => {
+                result.push(new PermissionDisplayModel(permissionElement));
+            });
+        }
+        return result;
+    }
+    getInheritedPermission(node) {
+        const result = [];
+        if (node?.permissions?.inherited) {
+            node.permissions.inherited.forEach((permissionElement) => {
+                const permissionInherited = new PermissionDisplayModel(permissionElement);
+                permissionInherited.isInherited = true;
+                result.push(permissionInherited);
+            });
+        }
+        return result;
+    }
+    /**
+     * Removes permissions setting from a node.
+     *
+     * @param node target node with permission
+     * @param permissions Permissions to remove
+     * @returns Node with modified permissions
+     */
+    removePermissions(node, permissions) {
+        const permissionBody = { permissions: { locallySet: [] } };
+        permissions.forEach((permission) => {
+            const index = node.permissions.locallySet.findIndex((locallySet) => locallySet.authorityId === permission.authorityId);
+            if (index !== -1) {
+                node.permissions.locallySet.splice(index, 1);
+            }
+        });
+        permissionBody.permissions.locallySet = node.permissions.locallySet;
+        return this.nodeService.updateNode(node.id, permissionBody);
+    }
+    /**
+     * updates permissions setting from a node.
+     *
+     * @param node target node with permission
+     * @param permissions Permissions to update
+     * @returns Node with modified permissions
+     */
+    updatePermissions(node, permissions) {
+        const permissionBody = { permissions: { locallySet: [] } };
+        permissionBody.permissions.locallySet = permissions;
+        return this.nodeService.updateNode(node.id, permissionBody);
+    }
+    /**
+     * Gets all node detail for nodeId along with settable permissions.
+     *
+     * @param nodeId Id of the node
+     * @returns node and it's associated roles { node: Node; roles: RoleModel[] }
+     */
+    getNodeWithRoles(nodeId) {
+        return this.nodeService.getNode(nodeId).pipe(switchMap((node) => forkJoin({
+            node: of(node),
+            roles: this.getNodeRoles(node).pipe(catchError(() => of(node.permissions?.settable)), map((_roles) => _roles.map((role) => ({ role, label: role }))))
+        })));
+    }
+    transformNodeToUserPerson(node) {
+        let person = null;
+        let group = null;
+        if (node.nodeType === 'cm:person') {
+            const firstName = node.properties['cm:firstName'];
+            const lastName = node.properties['cm:lastName'];
+            const email = node.properties['cm:email'];
+            const id = node.properties['cm:userName'];
+            person = new EcmUserModel({ id, firstName, lastName, email });
+        }
+        if (node.nodeType === 'cm:authorityContainer') {
+            const displayName = node.properties['cm:authorityDisplayName'] || node.properties['cm:authorityName'];
+            const id = node.properties['cm:authorityName'];
+            group = { displayName, id };
+        }
+        return { person, group };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodePermissionService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.SearchService }, { token: i3.NodesApiService }, { token: i4.TranslationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodePermissionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodePermissionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.SearchService }, { type: i3.NodesApiService }, { type: i4.TranslationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-permission.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/permission-manager/services/node-permission.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 { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport { TranslationService } from '@alfresco/adf-core';\nimport { NodesApiService } from '../../common/services/nodes-api.service';\nimport { EcmUserModel } from '../../common/models/ecm-user.model';\nimport { Group, GroupMemberPaging, GroupsApi, Node, PathElement, PermissionElement, SearchRequest } from '@alfresco/js-api';\nimport { SearchService } from '../../search/services/search.service';\nimport { Injectable } from '@angular/core';\nimport { forkJoin, from, Observable, of, throwError } from 'rxjs';\nimport { catchError, map, switchMap } from 'rxjs/operators';\nimport { PermissionDisplayModel } from '../models/permission.model';\nimport { RoleModel } from '../models/role.model';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class NodePermissionService {\n    private _groupsApi: GroupsApi;\n    get groupsApi(): GroupsApi {\n        this._groupsApi = this._groupsApi ?? new GroupsApi(this.apiService.getInstance());\n        return this._groupsApi;\n    }\n\n    constructor(\n        private apiService: AlfrescoApiService,\n        private searchApiService: SearchService,\n        private nodeService: NodesApiService,\n        private translation: TranslationService\n    ) {}\n\n    /**\n     * Gets a list of roles for the current node.\n     *\n     * @param node The target node\n     * @returns Array of strings representing the roles\n     */\n    getNodeRoles(node: Node): Observable<string[]> {\n        if (node.path.elements.some((el) => el.nodeType === 'st:site' || el.nodeType === 'st:sites')) {\n            const searchRequest = this.buildRetrieveSiteQueryBody(node.path.elements);\n            return this.searchApiService.searchByQueryBody(searchRequest).pipe(\n                switchMap((siteNodeList) => {\n                    const siteName = siteNodeList.list.entries[0].entry.name;\n                    return this.getGroupMembersBySiteName(siteName);\n                })\n            );\n        } else {\n            return of(node.permissions?.settable);\n        }\n    }\n\n    /**\n     * Get permissions for a given node\n     *\n     * @param node Node to check permissions for\n     * @returns list of permission models\n     */\n    getNodePermissions(node: Node): PermissionDisplayModel[] {\n        const result: PermissionDisplayModel[] = [];\n\n        if (node?.permissions?.locallySet) {\n            node.permissions.locallySet.map((permissionElement) => {\n                result.push(new PermissionDisplayModel(permissionElement));\n            });\n        }\n\n        if (node?.permissions?.inherited) {\n            node.permissions.inherited.map((permissionElement) => {\n                const permissionInherited = new PermissionDisplayModel(permissionElement);\n                permissionInherited.isInherited = true;\n                result.push(permissionInherited);\n            });\n        }\n        return result;\n    }\n\n    /**\n     * Updates the permission role for a node.\n     *\n     * @param node Target node\n     * @param updatedPermissionRole Permission role to update or add\n     * @returns Node with updated permission\n     */\n    updatePermissionRole(node: Node, updatedPermissionRole: PermissionElement): Observable<Node> {\n        const permissionBody = { permissions: { locallySet: [] } };\n        const index = node.permissions.locallySet.map((permission) => permission.authorityId).indexOf(updatedPermissionRole.authorityId);\n        permissionBody.permissions.locallySet = permissionBody.permissions.locallySet.concat(node.permissions.locallySet);\n        if (index !== -1) {\n            permissionBody.permissions.locallySet[index] = updatedPermissionRole;\n        } else {\n            permissionBody.permissions.locallySet.push(updatedPermissionRole);\n        }\n        return this.nodeService.updateNode(node.id, permissionBody);\n    }\n\n    /**\n     * Update permissions for a node.\n     *\n     * @param nodeId ID of the target node\n     * @param permissionList New permission settings\n     * @returns Node with updated permissions\n     */\n    updateNodePermissions(nodeId: string, permissionList: PermissionElement[]): Observable<Node> {\n        return this.nodeService.getNode(nodeId).pipe(switchMap((node) => this.updateLocallySetPermissions(node, permissionList)));\n    }\n\n    /**\n     * Updates the locally set permissions for a node.\n     *\n     * @param node ID of the target node\n     * @param permissions Permission settings\n     * @returns Node with updated permissions\n     */\n    updateLocallySetPermissions(node: Node, permissions: PermissionElement[]): Observable<Node> {\n        const permissionBody = { permissions: { locallySet: [] } };\n        const permissionList = permissions;\n        const duplicatedPermissions = this.getDuplicatedPermissions(node.permissions.locallySet, permissionList);\n        if (duplicatedPermissions.length > 0) {\n            const list = duplicatedPermissions\n                .map((permission) => 'authority -> ' + permission.authorityId + ' / role -> ' + permission.name)\n                .join(', ');\n            const duplicatePermissionMessage: string = this.translation.instant('PERMISSION_MANAGER.ERROR.DUPLICATE-PERMISSION', { list });\n            return throwError(duplicatePermissionMessage);\n        }\n        permissionBody.permissions.locallySet = node.permissions.locallySet ? node.permissions.locallySet.concat(permissionList) : permissionList;\n        return this.nodeService.updateNode(node.id, permissionBody);\n    }\n\n    private getDuplicatedPermissions(nodeLocallySet: PermissionElement[], permissionListAdded: PermissionElement[]): PermissionElement[] {\n        const duplicatePermissions: PermissionElement[] = [];\n        if (nodeLocallySet) {\n            permissionListAdded.forEach((permission) => {\n                const duplicate = nodeLocallySet.find((localPermission) => this.isEqualPermission(localPermission, permission));\n                if (duplicate) {\n                    duplicatePermissions.push(duplicate);\n                }\n            });\n        }\n        return duplicatePermissions;\n    }\n\n    private isEqualPermission(oldPermission: PermissionElement, newPermission: PermissionElement): boolean {\n        return (\n            oldPermission.accessStatus === newPermission.accessStatus &&\n            oldPermission.authorityId === newPermission.authorityId &&\n            oldPermission.name === newPermission.name\n        );\n    }\n\n    /**\n     * Removes a permission setting from a node.\n     *\n     * @param node ID of the target node\n     * @param permissionToRemove Permission setting to remove\n     * @returns Node with modified permissions\n     */\n    removePermission(node: Node, permissionToRemove: PermissionElement): Observable<Node> {\n        const permissionBody = { permissions: { locallySet: [] } };\n        const index = node.permissions.locallySet.map((permission) => permission.authorityId).indexOf(permissionToRemove.authorityId);\n\n        if (index !== -1) {\n            node.permissions.locallySet.splice(index, 1);\n            permissionBody.permissions.locallySet = node.permissions.locallySet;\n            return this.nodeService.updateNode(node.id, permissionBody);\n        } else {\n            return of(node);\n        }\n    }\n\n    private getGroupMembersBySiteName(siteName: string): Observable<string[]> {\n        const groupName = 'GROUP_site_' + siteName;\n        return this.getGroupMemberByGroupName(groupName).pipe(\n            map((groupMemberPaging) => {\n                const displayResult: string[] = [];\n                groupMemberPaging.list.entries.forEach((member) => {\n                    displayResult.push(this.formattedRoleName(member.entry.displayName, 'site_' + siteName));\n                });\n                return displayResult;\n            })\n        );\n    }\n\n    /**\n     * Gets all members related to a group name.\n     *\n     * @param groupName Name of group to look for members\n     * @param opts Extra options supported by JS-API\n     * @returns List of members\n     */\n    getGroupMemberByGroupName(groupName: string, opts?: any): Observable<GroupMemberPaging> {\n        return from(this.groupsApi.listGroupMemberships(groupName, opts));\n    }\n\n    private formattedRoleName(displayName, siteName): string {\n        return displayName.replace(siteName + '_', '');\n    }\n\n    private buildRetrieveSiteQueryBody(nodePath: PathElement[]): SearchRequest {\n        const pathNames = nodePath.map((node) => 'name: \"' + node.name + '\"');\n        const builtPathNames = pathNames.join(' OR ');\n\n        return {\n            query: {\n                query: builtPathNames\n            },\n            paging: {\n                maxItems: 100,\n                skipCount: 0\n            },\n            include: ['aspectNames', 'properties'],\n            filterQueries: [\n                {\n                    query: `TYPE:'st:site'`\n                }\n            ]\n        };\n    }\n\n    getLocalPermissions(node: Node): PermissionDisplayModel[] {\n        const result: PermissionDisplayModel[] = [];\n\n        if (node?.permissions?.locallySet) {\n            node.permissions.locallySet.forEach((permissionElement) => {\n                result.push(new PermissionDisplayModel(permissionElement));\n            });\n        }\n\n        return result;\n    }\n\n    getInheritedPermission(node: Node): PermissionDisplayModel[] {\n        const result: PermissionDisplayModel[] = [];\n\n        if (node?.permissions?.inherited) {\n            node.permissions.inherited.forEach((permissionElement) => {\n                const permissionInherited = new PermissionDisplayModel(permissionElement);\n                permissionInherited.isInherited = true;\n                result.push(permissionInherited);\n            });\n        }\n        return result;\n    }\n\n    /**\n     * Removes permissions setting from a node.\n     *\n     * @param node target node with permission\n     * @param permissions Permissions to remove\n     * @returns Node with modified permissions\n     */\n    removePermissions(node: Node, permissions: PermissionElement[]): Observable<Node> {\n        const permissionBody = { permissions: { locallySet: [] } };\n\n        permissions.forEach((permission) => {\n            const index = node.permissions.locallySet.findIndex((locallySet) => locallySet.authorityId === permission.authorityId);\n            if (index !== -1) {\n                node.permissions.locallySet.splice(index, 1);\n            }\n        });\n        permissionBody.permissions.locallySet = node.permissions.locallySet;\n        return this.nodeService.updateNode(node.id, permissionBody);\n    }\n\n    /**\n     * updates permissions setting from a node.\n     *\n     * @param node target node with permission\n     * @param permissions Permissions to update\n     * @returns Node with modified permissions\n     */\n    updatePermissions(node: Node, permissions: PermissionElement[]): Observable<Node> {\n        const permissionBody = { permissions: { locallySet: [] } };\n        permissionBody.permissions.locallySet = permissions;\n        return this.nodeService.updateNode(node.id, permissionBody);\n    }\n\n    /**\n     * Gets all node detail for nodeId along with settable permissions.\n     *\n     * @param nodeId Id of the node\n     * @returns node and it's associated roles { node: Node; roles: RoleModel[] }\n     */\n    getNodeWithRoles(nodeId: string): Observable<{ node: Node; roles: RoleModel[] }> {\n        return this.nodeService.getNode(nodeId).pipe(\n            switchMap((node) =>\n                forkJoin({\n                    node: of(node),\n                    roles: this.getNodeRoles(node).pipe(\n                        catchError(() => of(node.permissions?.settable)),\n                        map((_roles) => _roles.map((role) => ({ role, label: role })))\n                    )\n                })\n            )\n        );\n    }\n\n    transformNodeToUserPerson(node: Node): { person: EcmUserModel; group: Group } {\n        let person = null;\n        let group: Group = null;\n        if (node.nodeType === 'cm:person') {\n            const firstName = node.properties['cm:firstName'];\n            const lastName = node.properties['cm:lastName'];\n            const email = node.properties['cm:email'];\n            const id = node.properties['cm:userName'];\n            person = new EcmUserModel({ id, firstName, lastName, email });\n        }\n\n        if (node.nodeType === 'cm:authorityContainer') {\n            const displayName = node.properties['cm:authorityDisplayName'] || node.properties['cm:authorityName'];\n            const id = node.properties['cm:authorityName'];\n            group = { displayName, id };\n        }\n        return { person, group };\n    }\n}\n"]}

package/esm2022/lib/pipes/content-pipe.module.mjs

@@ -0,0 +1,37 @@
+/*!
+ * @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 { NodeNameTooltipPipe } from './node-name-tooltip.pipe';
+import * as i0 from "@angular/core";
+export const CONTENT_PIPES = [NodeNameTooltipPipe];
+/**
+ * @deprecated Use the individual pipe modules instead.
+ */
+export class ContentPipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: ContentPipeModule, imports: [NodeNameTooltipPipe], exports: [NodeNameTooltipPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentPipeModule, providers: [...CONTENT_PIPES] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...CONTENT_PIPES],
+                    providers: [...CONTENT_PIPES],
+                    exports: [...CONTENT_PIPES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pipes/index.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 * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3BpcGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/lib/pipes/node-name-tooltip.pipe.mjs

@@ -0,0 +1,69 @@
+/*!
+ * @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 { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NodeNameTooltipPipe {
+    transform(node) {
+        if (node) {
+            return this.getNodeTooltip(node);
+        }
+        return null;
+    }
+    containsLine(lines, line) {
+        return lines.some((item) => item.toLowerCase() === line.toLowerCase());
+    }
+    removeDuplicateLines(lines) {
+        const reducer = (acc, line) => {
+            if (!this.containsLine(acc, line)) {
+                acc.push(line);
+            }
+            return acc;
+        };
+        return lines.reduce(reducer, []);
+    }
+    getNodeTooltip(node) {
+        if (!node?.entry) {
+            return null;
+        }
+        const { entry: { properties, name } } = node;
+        const lines = [name];
+        if (properties) {
+            const { 'cm:title': title, 'cm:description': description } = properties;
+            if (title && description) {
+                lines[0] = title;
+                lines[1] = description;
+            }
+            if (title) {
+                lines[1] = title;
+            }
+            if (description) {
+                lines[1] = description;
+            }
+        }
+        return this.removeDuplicateLines(lines).join(`\n`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeNameTooltipPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: NodeNameTooltipPipe, isStandalone: true, name: "adfNodeNameTooltip" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeNameTooltipPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'adfNodeNameTooltip',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+/*!
+ * @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 './node-name-tooltip.pipe';
+export * from './content-pipe.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvcGlwZXMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbm9kZS1uYW1lLXRvb2x0aXAucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRlbnQtcGlwZS5tb2R1bGUnO1xuIl19

package/esm2022/lib/prediction/index.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 * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3ByZWRpY3Rpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/prediction/public-api.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 * from './services';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvcHJlZGljdGlvbi9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzJztcbiJdfQ==

package/esm2022/lib/prediction/services/index.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 * from './prediction.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3ByZWRpY3Rpb24vc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wcmVkaWN0aW9uLnNlcnZpY2UnO1xuIl19