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

package/esm2022/lib/permission-manager/components/permission-list/permission-list.service.mjs

@@ -0,0 +1,219 @@
+/*!
+ * @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 { NotificationService } from '@alfresco/adf-core';
+import { EventEmitter, Injectable } from '@angular/core';
+import { BehaviorSubject, forkJoin, of, Subject } from 'rxjs';
+import { finalize, map, switchMap } from 'rxjs/operators';
+import { NodePermissionService } from '../../services/node-permission.service';
+import { NodePermissionDialogService } from '../../services/node-permission-dialog.service';
+import { NodesApiService } from '../../../common/services/nodes-api.service';
+import { ContentService } from '../../../common/services/content.service';
+import { AllowableOperationsEnum } from '../../../common/models/allowable-operations.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../common/services/nodes-api.service";
+import * as i2 from "../../services/node-permission.service";
+import * as i3 from "../../services/node-permission-dialog.service";
+import * as i4 from "../../../common/services/content.service";
+import * as i5 from "@alfresco/adf-core";
+const SITE_MANAGER_ROLE = 'SiteManager';
+export class PermissionListService {
+    constructor(nodeService, nodePermissionService, nodePermissionDialogService, contentService, notificationService) {
+        this.nodeService = nodeService;
+        this.nodePermissionService = nodePermissionService;
+        this.nodePermissionDialogService = nodePermissionDialogService;
+        this.contentService = contentService;
+        this.notificationService = notificationService;
+        this.updated = new EventEmitter();
+        this.errored = new EventEmitter();
+        this.loading$ = new BehaviorSubject(true);
+        this.error$ = new Subject();
+        this.nodeWithRoles$ = new Subject();
+        this.data$ = this.nodeWithRoles$.pipe(map(({ node, roles }) => {
+            const nodeLocalPermissions = this.nodePermissionService.getLocalPermissions(node);
+            const localPermissions = this.updateReadOnlyPermission(node, nodeLocalPermissions);
+            return {
+                node,
+                roles,
+                localPermissions,
+                inheritedPermissions: this.nodePermissionService.getInheritedPermission(node)
+            };
+        }));
+    }
+    fetchPermission(nodeId) {
+        this.loading$.next(true);
+        this.nodePermissionService
+            .getNodeWithRoles(nodeId)
+            .pipe(finalize(() => this.loading$.next(false)))
+            .subscribe(({ node, roles }) => {
+            this.node = node;
+            this.roles = roles;
+            this.nodeWithRoles$.next({ node, roles });
+        }, () => this.error$.next(true));
+    }
+    toggleInherited(change) {
+        if (this.contentService.hasAllowableOperations(this.node, AllowableOperationsEnum.UPDATEPERMISSIONS)) {
+            let updateLocalPermission$ = of(null);
+            const nodeBody = {
+                permissions: {
+                    isInheritanceEnabled: !this.node.permissions.isInheritanceEnabled
+                }
+            };
+            const authorityId = this.getManagerAuthority(this.node);
+            if (authorityId) {
+                const permissions = [...(this.node.permissions.locallySet || []), { authorityId, name: SITE_MANAGER_ROLE, accessStatus: 'ALLOWED' }];
+                updateLocalPermission$ = this.nodePermissionService.updatePermissions(this.node, permissions);
+            }
+            updateLocalPermission$.pipe(switchMap(() => this.nodeService.updateNode(this.node.id, nodeBody, { include: ['permissions'] }))).subscribe((nodeUpdated) => {
+                const message = nodeUpdated.permissions.isInheritanceEnabled
+                    ? 'PERMISSION_MANAGER.MESSAGE.INHERIT-ENABLE-SUCCESS'
+                    : 'PERMISSION_MANAGER.MESSAGE.INHERIT-DISABLE-SUCCESS';
+                this.notificationService.showInfo(message);
+                nodeUpdated.permissions.inherited = nodeUpdated.permissions?.inherited ?? [];
+                this.reloadNode(nodeUpdated);
+            }, () => {
+                change.source.checked = this.node.permissions.isInheritanceEnabled;
+                this.notificationService.showWarning('PERMISSION_MANAGER.MESSAGE.TOGGLE-PERMISSION-FAILED');
+            });
+        }
+        else {
+            change.source.checked = this.node.permissions.isInheritanceEnabled;
+            this.notificationService.showError('PERMISSION_MANAGER.ERROR.NOT-ALLOWED');
+        }
+    }
+    updateNodePermissionByDialog() {
+        this.nodePermissionDialogService
+            .openAddPermissionDialog(this.node, this.roles, 'PERMISSION_MANAGER.ADD-PERMISSION.TITLE')
+            .pipe(switchMap((selection) => {
+            const total = selection.length;
+            const group = selection.filter(({ authorityId }) => this.isGroup(authorityId)).length;
+            return forkJoin({
+                user: of(total - group),
+                group: of(group),
+                node: this.nodePermissionService.updateNodePermissions(this.node.id, selection)
+            });
+        }))
+            .subscribe(({ user, group, node }) => {
+            this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-ADD-SUCCESS', null, { user, group });
+            this.reloadNode(node);
+        }, () => {
+            this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-ADD-FAIL');
+            this.reloadNode();
+        });
+    }
+    deletePermissions(permissions) {
+        this.nodePermissionService.removePermissions(this.node, permissions).subscribe((node) => {
+            const total = permissions.length;
+            const group = permissions.filter(({ authorityId }) => this.isGroup(authorityId)).length;
+            this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-BULK-DELETE-SUCCESS', null, { user: total - group, group });
+            this.reloadNode(node);
+        }, () => {
+            this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-DELETE-FAIL');
+            this.reloadNode();
+        });
+    }
+    updateRole(role, permission) {
+        const updatedPermissionRole = this.buildUpdatedPermission(role, permission);
+        this.nodePermissionService.updatePermissionRole(this.node, updatedPermissionRole).subscribe((node) => {
+            this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-UPDATE-SUCCESS');
+            this.reloadNode(node);
+            this.updated.emit(permission);
+        }, () => {
+            this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-UPDATE-FAIL');
+            this.reloadNode();
+            this.errored.emit(permission);
+        });
+    }
+    bulkRoleUpdate(role) {
+        const permissions = [...this.node.permissions.locallySet].map((permission) => this.buildUpdatedPermission(role, permission));
+        this.nodePermissionService.updatePermissions(this.node, permissions).subscribe((node) => {
+            const total = permissions.length;
+            const group = permissions.filter(({ authorityId }) => this.isGroup(authorityId)).length;
+            this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-BULK-UPDATE-SUCCESS', null, { user: total - group, group });
+            this.reloadNode(node);
+        }, () => {
+            this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-UPDATE-FAIL');
+            this.reloadNode();
+        });
+    }
+    deletePermission(permission) {
+        const cloneNode = { ...this.node, permissions: { ...this.node.permissions, locallySet: [...this.node.permissions.locallySet] } };
+        this.nodePermissionService.removePermission(cloneNode, permission).subscribe((node) => {
+            this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-DELETE-SUCCESS');
+            if (!node.permissions.locallySet) {
+                node.permissions.locallySet = [];
+            }
+            this.reloadNode(node);
+        }, () => {
+            this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-DELETE-FAIL');
+            this.reloadNode();
+        });
+    }
+    buildUpdatedPermission(role, permission) {
+        return {
+            accessStatus: permission.accessStatus,
+            name: this.canUpdateThePermission(this.node, permission) ? role : permission.name,
+            authorityId: permission.authorityId
+        };
+    }
+    reloadNode(node) {
+        if (node != null) {
+            Object.assign(this.node.permissions, node.permissions);
+        }
+        this.nodeWithRoles$.next({ node: this.node, roles: this.roles });
+    }
+    getManagerAuthority(node) {
+        const sitePath = node.path.elements.find((path) => path.nodeType === 'st:site');
+        let hasLocalManagerPermission = false;
+        let authorityId;
+        if (sitePath) {
+            authorityId = `GROUP_site_${sitePath.name}_${SITE_MANAGER_ROLE}`;
+            hasLocalManagerPermission = !!node.permissions.locallySet?.find((permission) => permission.authorityId === authorityId && permission.name === SITE_MANAGER_ROLE);
+        }
+        if (!hasLocalManagerPermission && authorityId) {
+            return authorityId;
+        }
+        return null;
+    }
+    updateReadOnlyPermission(node, permissions) {
+        permissions.forEach((permission) => {
+            if (!this.canUpdateThePermission(node, permission)) {
+                permission.readonly = true;
+            }
+        });
+        return permissions;
+    }
+    canUpdateThePermission(node, permission) {
+        const sitePath = node.path.elements.find((path) => path.nodeType === 'st:site');
+        if (!node.permissions.isInheritanceEnabled && sitePath) {
+            const authorityId = `GROUP_site_${sitePath.name}_${SITE_MANAGER_ROLE}`;
+            return !(permission.authorityId === authorityId && permission.name === SITE_MANAGER_ROLE);
+        }
+        return true;
+    }
+    isGroup(authorityId) {
+        return authorityId.startsWith('GROUP_') || authorityId.startsWith('ROLE_');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PermissionListService, deps: [{ token: i1.NodesApiService }, { token: i2.NodePermissionService }, { token: i3.NodePermissionDialogService }, { token: i4.ContentService }, { token: i5.NotificationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PermissionListService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PermissionListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.NodesApiService }, { type: i2.NodePermissionService }, { type: i3.NodePermissionDialogService }, { type: i4.ContentService }, { type: i5.NotificationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission-list.service.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/permission-manager/components/permission-list/permission-list.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 { NotificationService } from '@alfresco/adf-core';\nimport { Node, PermissionElement } from '@alfresco/js-api';\nimport { EventEmitter, Injectable } from '@angular/core';\nimport { MatSlideToggleChange } from '@angular/material/slide-toggle';\nimport { BehaviorSubject, forkJoin, Observable, of, Subject } from 'rxjs';\nimport { finalize, map, switchMap } from 'rxjs/operators';\nimport { RoleModel } from '../../models/role.model';\nimport { PermissionDisplayModel } from '../../models/permission.model';\nimport { NodePermissionsModel } from '../../models/member.model';\nimport { NodePermissionService } from '../../services/node-permission.service';\nimport { NodePermissionDialogService } from '../../services/node-permission-dialog.service';\nimport { NodesApiService } from '../../../common/services/nodes-api.service';\nimport { ContentService } from '../../../common/services/content.service';\nimport { AllowableOperationsEnum } from '../../../common/models/allowable-operations.enum';\n\nconst SITE_MANAGER_ROLE = 'SiteManager';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PermissionListService {\n    updated = new EventEmitter<PermissionDisplayModel>();\n    errored = new EventEmitter<PermissionDisplayModel>();\n\n    loading$: BehaviorSubject<boolean> = new BehaviorSubject(true);\n    error$: Subject<boolean> = new Subject();\n    nodeWithRoles$: Subject<{ node: Node; roles: RoleModel[] }> = new Subject();\n    data$: Observable<NodePermissionsModel> = this.nodeWithRoles$.pipe(\n        map(({ node, roles }) => {\n            const nodeLocalPermissions = this.nodePermissionService.getLocalPermissions(node);\n            const localPermissions = this.updateReadOnlyPermission(node, nodeLocalPermissions);\n            return {\n                node,\n                roles,\n                localPermissions,\n                inheritedPermissions: this.nodePermissionService.getInheritedPermission(node)\n            };\n        })\n    );\n\n    private node: Node;\n    private roles: RoleModel[];\n\n    constructor(\n        private nodeService: NodesApiService,\n        private nodePermissionService: NodePermissionService,\n        private nodePermissionDialogService: NodePermissionDialogService,\n        private contentService: ContentService,\n        private notificationService: NotificationService\n    ) {}\n\n    fetchPermission(nodeId: string) {\n        this.loading$.next(true);\n        this.nodePermissionService\n            .getNodeWithRoles(nodeId)\n            .pipe(finalize(() => this.loading$.next(false)))\n            .subscribe(\n                ({ node, roles }) => {\n                    this.node = node;\n                    this.roles = roles;\n                    this.nodeWithRoles$.next({ node, roles });\n                },\n                () => this.error$.next(true)\n            );\n    }\n\n    toggleInherited(change: MatSlideToggleChange) {\n        if (this.contentService.hasAllowableOperations(this.node, AllowableOperationsEnum.UPDATEPERMISSIONS)) {\n            let updateLocalPermission$: Observable<Node> = of(null);\n            const nodeBody = {\n                permissions: {\n                    isInheritanceEnabled: !this.node.permissions.isInheritanceEnabled\n                }\n            };\n\n            const authorityId = this.getManagerAuthority(this.node);\n            if (authorityId) {\n                const permissions = [...(this.node.permissions.locallySet || []), { authorityId, name: SITE_MANAGER_ROLE, accessStatus: 'ALLOWED' }];\n                updateLocalPermission$ = this.nodePermissionService.updatePermissions(this.node, permissions);\n            }\n\n            updateLocalPermission$.pipe(switchMap(() => this.nodeService.updateNode(this.node.id, nodeBody, { include: ['permissions'] }))).subscribe(\n                (nodeUpdated: Node) => {\n                    const message = nodeUpdated.permissions.isInheritanceEnabled\n                        ? 'PERMISSION_MANAGER.MESSAGE.INHERIT-ENABLE-SUCCESS'\n                        : 'PERMISSION_MANAGER.MESSAGE.INHERIT-DISABLE-SUCCESS';\n                    this.notificationService.showInfo(message);\n                    nodeUpdated.permissions.inherited = nodeUpdated.permissions?.inherited ?? [];\n                    this.reloadNode(nodeUpdated);\n                },\n                () => {\n                    change.source.checked = this.node.permissions.isInheritanceEnabled;\n                    this.notificationService.showWarning('PERMISSION_MANAGER.MESSAGE.TOGGLE-PERMISSION-FAILED');\n                }\n            );\n        } else {\n            change.source.checked = this.node.permissions.isInheritanceEnabled;\n            this.notificationService.showError('PERMISSION_MANAGER.ERROR.NOT-ALLOWED');\n        }\n    }\n\n    updateNodePermissionByDialog() {\n        this.nodePermissionDialogService\n            .openAddPermissionDialog(this.node, this.roles, 'PERMISSION_MANAGER.ADD-PERMISSION.TITLE')\n            .pipe(\n                switchMap((selection) => {\n                    const total = selection.length;\n                    const group = selection.filter(({ authorityId }) => this.isGroup(authorityId)).length;\n                    return forkJoin({\n                        user: of(total - group),\n                        group: of(group),\n                        node: this.nodePermissionService.updateNodePermissions(this.node.id, selection)\n                    });\n                })\n            )\n            .subscribe(\n                ({ user, group, node }) => {\n                    this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-ADD-SUCCESS', null, { user, group });\n                    this.reloadNode(node);\n                },\n                () => {\n                    this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-ADD-FAIL');\n                    this.reloadNode();\n                }\n            );\n    }\n\n    deletePermissions(permissions: PermissionElement[]) {\n        this.nodePermissionService.removePermissions(this.node, permissions).subscribe(\n            (node) => {\n                const total = permissions.length;\n                const group = permissions.filter(({ authorityId }) => this.isGroup(authorityId)).length;\n                this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-BULK-DELETE-SUCCESS', null, { user: total - group, group });\n                this.reloadNode(node);\n            },\n            () => {\n                this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-DELETE-FAIL');\n                this.reloadNode();\n            }\n        );\n    }\n\n    updateRole(role: string, permission: PermissionDisplayModel) {\n        const updatedPermissionRole = this.buildUpdatedPermission(role, permission);\n        this.nodePermissionService.updatePermissionRole(this.node, updatedPermissionRole).subscribe(\n            (node) => {\n                this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-UPDATE-SUCCESS');\n                this.reloadNode(node);\n                this.updated.emit(permission);\n            },\n            () => {\n                this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-UPDATE-FAIL');\n                this.reloadNode();\n                this.errored.emit(permission);\n            }\n        );\n    }\n\n    bulkRoleUpdate(role: string) {\n        const permissions = [...this.node.permissions.locallySet].map((permission) => this.buildUpdatedPermission(role, permission));\n        this.nodePermissionService.updatePermissions(this.node, permissions).subscribe(\n            (node) => {\n                const total = permissions.length;\n                const group = permissions.filter(({ authorityId }) => this.isGroup(authorityId)).length;\n                this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-BULK-UPDATE-SUCCESS', null, { user: total - group, group });\n                this.reloadNode(node);\n            },\n            () => {\n                this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-UPDATE-FAIL');\n                this.reloadNode();\n            }\n        );\n    }\n\n    deletePermission(permission: PermissionDisplayModel) {\n        const cloneNode = { ...this.node, permissions: { ...this.node.permissions, locallySet: [...this.node.permissions.locallySet] } };\n        this.nodePermissionService.removePermission(cloneNode, permission).subscribe(\n            (node) => {\n                this.notificationService.showInfo('PERMISSION_MANAGER.MESSAGE.PERMISSION-DELETE-SUCCESS');\n                if (!node.permissions.locallySet) {\n                    node.permissions.locallySet = [];\n                }\n                this.reloadNode(node);\n            },\n            () => {\n                this.notificationService.showError('PERMISSION_MANAGER.MESSAGE.PERMISSION-DELETE-FAIL');\n                this.reloadNode();\n            }\n        );\n    }\n\n    private buildUpdatedPermission(role: string, permission: PermissionElement): PermissionElement {\n        return {\n            accessStatus: permission.accessStatus,\n            name: this.canUpdateThePermission(this.node, permission) ? role : permission.name,\n            authorityId: permission.authorityId\n        };\n    }\n\n    private reloadNode(node?: Node) {\n        if (node != null) {\n            Object.assign(this.node.permissions, node.permissions);\n        }\n        this.nodeWithRoles$.next({ node: this.node, roles: this.roles });\n    }\n\n    getManagerAuthority(node: Node): string {\n        const sitePath = node.path.elements.find((path) => path.nodeType === 'st:site');\n        let hasLocalManagerPermission = false;\n        let authorityId: string;\n        if (sitePath) {\n            authorityId = `GROUP_site_${sitePath.name}_${SITE_MANAGER_ROLE}`;\n            hasLocalManagerPermission = !!node.permissions.locallySet?.find(\n                (permission) => permission.authorityId === authorityId && permission.name === SITE_MANAGER_ROLE\n            );\n        }\n\n        if (!hasLocalManagerPermission && authorityId) {\n            return authorityId;\n        }\n        return null;\n    }\n\n    updateReadOnlyPermission(node: Node, permissions: PermissionDisplayModel[]): PermissionDisplayModel[] {\n        permissions.forEach((permission) => {\n            if (!this.canUpdateThePermission(node, permission)) {\n                permission.readonly = true;\n            }\n        });\n        return permissions;\n    }\n\n    canUpdateThePermission(node: Node, permission: PermissionElement): boolean {\n        const sitePath = node.path.elements.find((path) => path.nodeType === 'st:site');\n        if (!node.permissions.isInheritanceEnabled && sitePath) {\n            const authorityId = `GROUP_site_${sitePath.name}_${SITE_MANAGER_ROLE}`;\n            return !(permission.authorityId === authorityId && permission.name === SITE_MANAGER_ROLE);\n        }\n        return true;\n    }\n\n    private isGroup(authorityId) {\n        return authorityId.startsWith('GROUP_') || authorityId.startsWith('ROLE_');\n    }\n}\n"]}

package/esm2022/lib/permission-manager/components/pop-over.directive.mjs

@@ -0,0 +1,134 @@
+/*!
+ * @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 { DestroyRef, Directive, ElementRef, HostListener, inject, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ConnectionPositionPair, Overlay } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { ConfigurableFocusTrapFactory } from '@angular/cdk/a11y';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/cdk/a11y";
+export class PopOverDirective {
+    get open() {
+        return this._open;
+    }
+    constructor(element, overlay, vcr, focusTrapFactory) {
+        this.element = element;
+        this.overlay = overlay;
+        this.vcr = vcr;
+        this.focusTrapFactory = focusTrapFactory;
+        this.panelClass = 'adf-permission-pop-over';
+        this._open = false;
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.createOverlay();
+    }
+    ngAfterViewInit() {
+        this.element.nativeElement.addEventListener('click', () => this.toggleOverlay());
+        this.element.nativeElement.addEventListener('keydown', this.preventDefaultForEnter);
+    }
+    ngOnDestroy() {
+        this.element.nativeElement.removeEventListener('keydown', this.preventDefaultForEnter);
+        this.detachOverlay();
+    }
+    createOverlay() {
+        const scrollStrategy = this.overlay.scrollStrategies.reposition();
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(this.target)
+            .withPositions([
+            new ConnectionPositionPair({ originX: 'start', originY: 'bottom' }, { overlayX: 'start', overlayY: 'top' }),
+            new ConnectionPositionPair({ originX: 'start', originY: 'top' }, { overlayX: 'start', overlayY: 'bottom' })
+        ])
+            .withPush(false);
+        this.overlayRef = this.overlay.create({
+            positionStrategy,
+            scrollStrategy,
+            hasBackdrop: true,
+            backdropClass: 'cdk-overlay-transparent-backdrop',
+            panelClass: this.panelClass
+        });
+        this.overlayRef
+            .backdropClick()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            this.detachOverlay();
+        });
+    }
+    toggleOverlay() {
+        if (!this.overlayRef.hasAttached()) {
+            this.attachOverlay();
+        }
+        else {
+            this.detachOverlay();
+        }
+    }
+    attachOverlay() {
+        if (!this.overlayRef.hasAttached()) {
+            const periodSelectorPortal = new TemplatePortal(this.popOver, this.vcr);
+            this.overlayRef.attach(periodSelectorPortal);
+            this._open = true;
+            if (this.autofocusedElementSelector) {
+                this.overlayRef.overlayElement.querySelector(this.autofocusedElementSelector).focus();
+            }
+            if (this.popOver && !this.focusTrap) {
+                this.focusTrap = this.focusTrapFactory.create(this.overlayRef.overlayElement);
+            }
+        }
+    }
+    detachOverlay() {
+        if (this.overlayRef.hasAttached()) {
+            this.overlayRef.detach();
+            this._open = false;
+            this.focusTrap.destroy();
+            this.focusTrap = null;
+            this.element.nativeElement.focus();
+        }
+    }
+    preventDefaultForEnter(event) {
+        if (event.key === 'Enter') {
+            event.preventDefault();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PopOverDirective, deps: [{ token: i0.ElementRef }, { token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i2.ConfigurableFocusTrapFactory }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: PopOverDirective, isStandalone: true, selector: "[adf-pop-over]", inputs: { popOver: ["adf-pop-over", "popOver"], target: "target", panelClass: "panelClass", autofocusedElementSelector: "autofocusedElementSelector" }, host: { listeners: { "keyup.enter": "toggleOverlay()", "document:keyup.esc": "detachOverlay()" } }, exportAs: ["adfPopOver"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PopOverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-pop-over]',
+                    standalone: true,
+                    exportAs: 'adfPopOver'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i2.ConfigurableFocusTrapFactory }], propDecorators: { popOver: [{
+                type: Input,
+                args: ['adf-pop-over']
+            }], target: [{
+                type: Input
+            }], panelClass: [{
+                type: Input
+            }], autofocusedElementSelector: [{
+                type: Input
+            }], toggleOverlay: [{
+                type: HostListener,
+                args: ['keyup.enter']
+            }], detachOverlay: [{
+                type: HostListener,
+                args: ['document:keyup.esc']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pop-over.directive.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/permission-manager/components/pop-over.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n    AfterViewInit,\n    DestroyRef,\n    Directive,\n    ElementRef,\n    HostListener,\n    inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    TemplateRef,\n    ViewContainerRef\n} from '@angular/core';\nimport { ConnectionPositionPair, Overlay, OverlayRef } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { ConfigurableFocusTrap, ConfigurableFocusTrapFactory } from '@angular/cdk/a11y';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Directive({\n    selector: '[adf-pop-over]',\n    standalone: true,\n    exportAs: 'adfPopOver'\n})\nexport class PopOverDirective implements OnInit, OnDestroy, AfterViewInit {\n    get open(): boolean {\n        return this._open;\n    }\n\n    @Input('adf-pop-over') popOver!: TemplateRef<any>;\n    @Input() target!: HTMLElement;\n    @Input() panelClass = 'adf-permission-pop-over';\n    @Input() autofocusedElementSelector: string;\n\n    private _open = false;\n    private overlayRef!: OverlayRef;\n    private focusTrap: ConfigurableFocusTrap;\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    constructor(\n        private element: ElementRef,\n        private overlay: Overlay,\n        private vcr: ViewContainerRef,\n        private focusTrapFactory: ConfigurableFocusTrapFactory\n    ) {}\n\n    ngOnInit(): void {\n        this.createOverlay();\n    }\n\n    ngAfterViewInit(): void {\n        this.element.nativeElement.addEventListener('click', () => this.toggleOverlay());\n        this.element.nativeElement.addEventListener('keydown', this.preventDefaultForEnter);\n    }\n\n    ngOnDestroy(): void {\n        this.element.nativeElement.removeEventListener('keydown', this.preventDefaultForEnter);\n        this.detachOverlay();\n    }\n\n    private createOverlay(): void {\n        const scrollStrategy = this.overlay.scrollStrategies.reposition();\n        const positionStrategy = this.overlay\n            .position()\n            .flexibleConnectedTo(this.target)\n            .withPositions([\n                new ConnectionPositionPair({ originX: 'start', originY: 'bottom' }, { overlayX: 'start', overlayY: 'top' }),\n                new ConnectionPositionPair({ originX: 'start', originY: 'top' }, { overlayX: 'start', overlayY: 'bottom' })\n            ])\n            .withPush(false);\n\n        this.overlayRef = this.overlay.create({\n            positionStrategy,\n            scrollStrategy,\n            hasBackdrop: true,\n            backdropClass: 'cdk-overlay-transparent-backdrop',\n            panelClass: this.panelClass\n        });\n\n        this.overlayRef\n            .backdropClick()\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe(() => {\n                this.detachOverlay();\n            });\n    }\n\n    @HostListener('keyup.enter')\n    private toggleOverlay(): void {\n        if (!this.overlayRef.hasAttached()) {\n            this.attachOverlay();\n        } else {\n            this.detachOverlay();\n        }\n    }\n\n    private attachOverlay(): void {\n        if (!this.overlayRef.hasAttached()) {\n            const periodSelectorPortal = new TemplatePortal(this.popOver, this.vcr);\n\n            this.overlayRef.attach(periodSelectorPortal);\n            this._open = true;\n            if (this.autofocusedElementSelector) {\n                this.overlayRef.overlayElement.querySelector<HTMLElement>(this.autofocusedElementSelector).focus();\n            }\n\n            if (this.popOver && !this.focusTrap) {\n                this.focusTrap = this.focusTrapFactory.create(this.overlayRef.overlayElement);\n            }\n        }\n    }\n\n    @HostListener('document:keyup.esc')\n    private detachOverlay(): void {\n        if (this.overlayRef.hasAttached()) {\n            this.overlayRef.detach();\n            this._open = false;\n\n            this.focusTrap.destroy();\n            this.focusTrap = null;\n\n            this.element.nativeElement.focus();\n        }\n    }\n\n    private preventDefaultForEnter(event: KeyboardEvent): void {\n        if (event.key === 'Enter') {\n            event.preventDefault();\n        }\n    }\n}\n"]}

package/esm2022/lib/permission-manager/components/user-icon-column/user-icon-column.component.mjs

@@ -0,0 +1,88 @@
+/*!
+ * @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 { InitialUsernamePipe, User } from '@alfresco/adf-core';
+import { NodeEntry } from '@alfresco/js-api';
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { NodePermissionService } from '../../services/node-permission.service';
+import { CommonModule } from '@angular/common';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/node-permission.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/icon";
+export class UserIconColumnComponent {
+    get isSelected() {
+        return this.context?.row?.isSelected || this.selected;
+    }
+    constructor(nodePermissionService) {
+        this.nodePermissionService = nodePermissionService;
+        this.selected = false;
+        this.displayText$ = new BehaviorSubject(null);
+        this.group = false;
+    }
+    ngOnInit() {
+        if (this.context) {
+            const { person, group, authorityId } = this.context.row.obj?.entry ?? this.context.row.obj;
+            this.group = this.isGroup(group, authorityId);
+            const user = person ? new User(person) : undefined;
+            this.displayText$.next(user || group || { displayName: authorityId });
+        }
+        if (this.node) {
+            const { person, group } = this.nodePermissionService.transformNodeToUserPerson(this.node.entry);
+            this.group = this.isGroup(group, null);
+            const user = person ? new User(person) : undefined;
+            this.displayText$.next(user || group);
+        }
+    }
+    isGroup(group, authorityId) {
+        return !!group || authorityId?.startsWith('GROUP_') || authorityId?.startsWith('ROLE_');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserIconColumnComponent, deps: [{ token: i1.NodePermissionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: UserIconColumnComponent, isStandalone: true, selector: "adf-user-icon-column", inputs: { context: "context", node: "node", selected: "selected" }, host: { classAttribute: "adf-user-icon-column adf-datatable-content-cell" }, ngImport: i0, template: `
+        <div class="adf-cell-value" [attr.id]="group ? 'group-icon' : 'person-icon'" *ngIf="!isSelected">
+            <ng-container *ngIf="displayText$ | async as user">
+                <mat-icon *ngIf="group" class="adf-group-icon">people_alt_outline</mat-icon>
+                <div *ngIf="!group" [outerHTML]="user | usernameInitials : 'adf-people-initial'"></div>
+            </ng-container>
+        </div>
+        <div class="adf-cell-value" *ngIf="isSelected">
+            <mat-icon class="adf-people-select-icon adf-datatable-selected" svgIcon="selected" />
+        </div>
+    `, isInline: true, styles: [".adf-cell-value .adf-people-initial{background:var(--theme-primary-color);border-radius:50%;display:flex;justify-content:center;align-items:center;width:40px;height:40px;color:var(--theme-primary-color-default-contrast);font-weight:bolder;font-size:var(--theme-adf-picture-1-font-size);text-transform:uppercase}.adf-cell-value .adf-group-icon{height:20px;width:20px;background:var(--theme-primary-color);border-radius:50%;padding:10px;color:var(--theme-primary-color-default-contrast);font-weight:bolder;font-size:var(--theme-title-font-size)}.adf-cell-value .adf-datatable-selected{height:100%;width:100%;margin-left:-2px;margin-top:2px}.adf-cell-value .adf-people-select-icon{margin:0}.adf-cell-value .adf-people-select-icon svg{fill:var(--theme-accent-color);width:40px;height:40px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: InitialUsernamePipe, name: "usernameInitials" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserIconColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-user-icon-column', standalone: true, imports: [CommonModule, MatIconModule, InitialUsernamePipe], template: `
+        <div class="adf-cell-value" [attr.id]="group ? 'group-icon' : 'person-icon'" *ngIf="!isSelected">
+            <ng-container *ngIf="displayText$ | async as user">
+                <mat-icon *ngIf="group" class="adf-group-icon">people_alt_outline</mat-icon>
+                <div *ngIf="!group" [outerHTML]="user | usernameInitials : 'adf-people-initial'"></div>
+            </ng-container>
+        </div>
+        <div class="adf-cell-value" *ngIf="isSelected">
+            <mat-icon class="adf-people-select-icon adf-datatable-selected" svgIcon="selected" />
+        </div>
+    `, encapsulation: ViewEncapsulation.None, host: { class: 'adf-user-icon-column adf-datatable-content-cell' }, styles: [".adf-cell-value .adf-people-initial{background:var(--theme-primary-color);border-radius:50%;display:flex;justify-content:center;align-items:center;width:40px;height:40px;color:var(--theme-primary-color-default-contrast);font-weight:bolder;font-size:var(--theme-adf-picture-1-font-size);text-transform:uppercase}.adf-cell-value .adf-group-icon{height:20px;width:20px;background:var(--theme-primary-color);border-radius:50%;padding:10px;color:var(--theme-primary-color-default-contrast);font-weight:bolder;font-size:var(--theme-title-font-size)}.adf-cell-value .adf-datatable-selected{height:100%;width:100%;margin-left:-2px;margin-top:2px}.adf-cell-value .adf-people-select-icon{margin:0}.adf-cell-value .adf-people-select-icon svg{fill:var(--theme-accent-color);width:40px;height:40px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.NodePermissionService }], propDecorators: { context: [{
+                type: Input
+            }], node: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/permission-manager/components/user-name-column/user-name-column.component.mjs

@@ -0,0 +1,82 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { NodeEntry } from '@alfresco/js-api';
+import { NodePermissionService } from '../../services/node-permission.service';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/node-permission.service";
+import * as i2 from "@angular/common";
+export class UserNameColumnComponent {
+    constructor(nodePermissionService) {
+        this.nodePermissionService = nodePermissionService;
+        this.displayText$ = new BehaviorSubject('');
+        this.subTitleText$ = new BehaviorSubject('');
+    }
+    ngOnInit() {
+        if (this.context != null) {
+            const { person, group, authorityId } = this.context.row.obj?.entry ?? this.context.row.obj;
+            const permissionGroup = authorityId ? { displayName: authorityId } : null;
+            this.updatePerson(person);
+            this.updateGroup(group || permissionGroup);
+        }
+        if (this.node) {
+            const { person, group } = this.nodePermissionService.transformNodeToUserPerson(this.node.entry);
+            this.updatePerson(person);
+            this.updateGroup(group);
+        }
+    }
+    updatePerson(person) {
+        if (person) {
+            this.displayText$.next(`${person.firstName ?? ''} ${person.lastName ?? ''}`);
+            this.subTitleText$.next(person.email ?? '');
+        }
+    }
+    updateGroup(group) {
+        if (group) {
+            this.displayText$.next(group.displayName || group.id);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserNameColumnComponent, deps: [{ token: i1.NodePermissionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: UserNameColumnComponent, isStandalone: true, selector: "adf-user-name-column", inputs: { context: "context", node: "node" }, host: { classAttribute: "adf-user-name-column adf-datatable-content-cell adf-expand-cell-5 adf-ellipsis-cell" }, ngImport: i0, template: `
+        <div class="adf-ellipsis-cell" [attr.data-automation-id]="displayText$ | async">
+            <span class="adf-user-name-column" title="{{ displayText$ | async }}"> {{ displayText$ | async }}</span>
+            <br />
+            <span class="adf-user-email-column" title="{{ subTitleText$ | async }}" *ngIf="subTitleText$ | async">
+                {{ subTitleText$ | async }}
+            </span>
+        </div>
+    `, isInline: true, styles: [".adf-user-name-column{font-weight:600;font-size:var(--theme-body-1-font-size)}.adf-user-email-column{font-size:var(--theme-body-1-font-size);letter-spacing:-.2px;line-height:1.43;color:var(--adf-theme-foreground-text-color)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserNameColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-user-name-column', standalone: true, imports: [CommonModule], template: `
+        <div class="adf-ellipsis-cell" [attr.data-automation-id]="displayText$ | async">
+            <span class="adf-user-name-column" title="{{ displayText$ | async }}"> {{ displayText$ | async }}</span>
+            <br />
+            <span class="adf-user-email-column" title="{{ subTitleText$ | async }}" *ngIf="subTitleText$ | async">
+                {{ subTitleText$ | async }}
+            </span>
+        </div>
+    `, encapsulation: ViewEncapsulation.None, host: { class: 'adf-user-name-column adf-datatable-content-cell adf-expand-cell-5 adf-ellipsis-cell' }, styles: [".adf-user-name-column{font-weight:600;font-size:var(--theme-body-1-font-size)}.adf-user-email-column{font-size:var(--theme-body-1-font-size);letter-spacing:-.2px;line-height:1.43;color:var(--adf-theme-foreground-text-color)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.NodePermissionService }], propDecorators: { context: [{
+                type: Input
+            }], node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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