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

package/esm2022/lib/directives/node-favorite.directive.mjs

@@ -0,0 +1,193 @@
+/*!
+ * @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.
+ */
+/* eslint-disable @angular-eslint/no-input-rename */
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { FavoritesApi } from '@alfresco/js-api';
+import { from, forkJoin, of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { AlfrescoApiService } from '../services/alfresco-api.service';
+import { NotificationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export class NodeFavoriteDirective {
+    get favoritesApi() {
+        this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.alfrescoApiService.getInstance());
+        return this._favoritesApi;
+    }
+    onClick() {
+        this.toggleFavorite();
+    }
+    constructor(alfrescoApiService, notificationService) {
+        this.alfrescoApiService = alfrescoApiService;
+        this.notificationService = notificationService;
+        this.favorites = [];
+        /** Array of nodes to toggle as favorites. */
+        this.selection = [];
+        /** Emitted when the favorite setting is complete. */
+        this.toggle = new EventEmitter();
+        /** Emitted when the favorite setting fails. */
+        this.error = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        if (!changes.selection.currentValue.length) {
+            this.favorites = [];
+            return;
+        }
+        this.markFavoritesNodes(changes.selection.currentValue);
+    }
+    toggleFavorite() {
+        if (!this.favorites.length) {
+            return;
+        }
+        const every = this.favorites.every((selected) => selected.entry.isFavorite);
+        if (every) {
+            const batch = this.favorites.map((selected) => {
+                // shared files have nodeId
+                const id = selected.entry.nodeId || selected.entry.id;
+                return from(this.favoritesApi.deleteFavorite('-me-', id));
+            });
+            forkJoin(batch).subscribe({
+                next: () => {
+                    this.favorites.forEach((selected) => (selected.entry.isFavorite = false));
+                    if (this.favorites.length > 1) {
+                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODES_REMOVED', null, { number: this.favorites.length });
+                    }
+                    else {
+                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODE_REMOVED', null, {
+                            name: this.favorites[0].entry.name
+                        });
+                    }
+                    this.toggle.emit();
+                },
+                error: (error) => this.error.emit(error)
+            });
+        }
+        if (!every) {
+            const notFavorite = this.favorites.filter((node) => !node.entry.isFavorite);
+            const body = notFavorite.map((node) => this.createFavoriteBody(node));
+            from(this.favoritesApi.createFavorite('-me-', body)).subscribe({
+                next: () => {
+                    notFavorite.forEach((selected) => (selected.entry.isFavorite = true));
+                    if (notFavorite.length > 1) {
+                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODES_ADDED', null, { number: notFavorite.length });
+                    }
+                    else {
+                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODE_ADDED', null, { name: notFavorite[0].entry.name });
+                    }
+                    this.toggle.emit();
+                },
+                error: (error) => this.error.emit(error)
+            });
+        }
+    }
+    markFavoritesNodes(selection) {
+        if (selection.length <= this.favorites.length) {
+            this.favorites = this.reduce(this.favorites, selection);
+        }
+        const result = this.diff(selection, this.favorites);
+        const batch = this.getProcessBatch(result);
+        forkJoin(batch).subscribe((data) => {
+            this.favorites.push(...data);
+        });
+    }
+    hasFavorites() {
+        if (this.favorites && !this.favorites.length) {
+            return false;
+        }
+        return this.favorites.every((selected) => selected.entry.isFavorite);
+    }
+    getProcessBatch(selection) {
+        return selection.map((selected) => this.getFavorite(selected));
+    }
+    getFavorite(selected) {
+        const node = selected.entry;
+        // ACS 6.x with 'isFavorite' include
+        if (node && Object.prototype.hasOwnProperty.call(node, 'isFavorite')) {
+            return of(selected);
+        }
+        // ACS 5.x and 6.x without 'isFavorite' include
+        const { name, isFile, isFolder } = node;
+        const id = node.nodeId || node.id;
+        const promise = this.favoritesApi.getFavorite('-me-', id);
+        return from(promise).pipe(map(() => ({
+            entry: {
+                id,
+                isFolder,
+                isFile,
+                name,
+                isFavorite: true
+            }
+        })), catchError(() => of({
+            entry: {
+                id,
+                isFolder,
+                isFile,
+                name,
+                isFavorite: false
+            }
+        })));
+    }
+    createFavoriteBody(node) {
+        const type = this.getNodeType(node);
+        // shared files have nodeId
+        const id = node.entry['nodeId'] || node.entry.id;
+        return {
+            target: {
+                [type]: {
+                    guid: id
+                }
+            }
+        };
+    }
+    getNodeType(node) {
+        // shared could only be files
+        if (!node.entry.isFile && !node.entry.isFolder) {
+            return 'file';
+        }
+        return node.entry.isFile ? 'file' : 'folder';
+    }
+    diff(list, patch) {
+        const ids = patch.map((item) => item.entry.id);
+        return list.filter((item) => (ids.includes(item.entry.id) ? null : item));
+    }
+    reduce(patch, comparator) {
+        const ids = comparator.map((item) => item.entry.id);
+        return patch.filter((item) => (ids.includes(item.entry.id) ? item : null));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeFavoriteDirective, deps: [{ token: i1.AlfrescoApiService }, { token: i2.NotificationService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NodeFavoriteDirective, isStandalone: true, selector: "[adf-node-favorite]", inputs: { selection: ["adf-node-favorite", "selection"] }, outputs: { toggle: "toggle", error: "error" }, host: { listeners: { "click": "onClick()" } }, exportAs: ["adfFavorite"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeFavoriteDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[adf-node-favorite]',
+                    exportAs: 'adfFavorite'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.NotificationService }], propDecorators: { selection: [{
+                type: Input,
+                args: ['adf-node-favorite']
+            }], toggle: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-favorite.directive.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/directives/node-favorite.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\n/* eslint-disable @angular-eslint/no-input-rename */\n\nimport { Directive, EventEmitter, HostListener, Input, OnChanges, Output, SimpleChanges } from '@angular/core';\nimport { FavoriteBodyCreate, NodeEntry, SharedLinkEntry, Node, SharedLink, FavoritesApi } from '@alfresco/js-api';\nimport { Observable, from, forkJoin, of } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { AlfrescoApiService } from '../services/alfresco-api.service';\nimport { NotificationService } from '@alfresco/adf-core';\n\n@Directive({\n    standalone: true,\n    selector: '[adf-node-favorite]',\n    exportAs: 'adfFavorite'\n})\nexport class NodeFavoriteDirective implements OnChanges {\n    favorites: any[] = [];\n\n    private _favoritesApi: FavoritesApi;\n    get favoritesApi(): FavoritesApi {\n        this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.alfrescoApiService.getInstance());\n        return this._favoritesApi;\n    }\n\n    /** Array of nodes to toggle as favorites. */\n    @Input('adf-node-favorite')\n    selection: NodeEntry[] = [];\n\n    /** Emitted when the favorite setting is complete. */\n    @Output() toggle = new EventEmitter<any>();\n\n    /** Emitted when the favorite setting fails. */\n    @Output() error = new EventEmitter<any>();\n\n    @HostListener('click')\n    onClick() {\n        this.toggleFavorite();\n    }\n\n    constructor(private readonly alfrescoApiService: AlfrescoApiService, private readonly notificationService: NotificationService) {}\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (!changes.selection.currentValue.length) {\n            this.favorites = [];\n\n            return;\n        }\n\n        this.markFavoritesNodes(changes.selection.currentValue);\n    }\n\n    toggleFavorite() {\n        if (!this.favorites.length) {\n            return;\n        }\n\n        const every = this.favorites.every((selected) => selected.entry.isFavorite);\n\n        if (every) {\n            const batch = this.favorites.map((selected: NodeEntry | SharedLinkEntry) => {\n                // shared files have nodeId\n                const id = (selected as SharedLinkEntry).entry.nodeId || selected.entry.id;\n\n                return from(this.favoritesApi.deleteFavorite('-me-', id));\n            });\n\n            forkJoin(batch).subscribe({\n                next: () => {\n                    this.favorites.forEach((selected) => (selected.entry.isFavorite = false));\n                    if (this.favorites.length > 1) {\n                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODES_REMOVED', null, { number: this.favorites.length });\n                    } else {\n                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODE_REMOVED', null, {\n                            name: this.favorites[0].entry.name\n                        });\n                    }\n                    this.toggle.emit();\n                },\n                error: (error) => this.error.emit(error)\n            });\n        }\n\n        if (!every) {\n            const notFavorite = this.favorites.filter((node) => !node.entry.isFavorite);\n            const body = notFavorite.map((node) => this.createFavoriteBody(node));\n\n            from(this.favoritesApi.createFavorite('-me-', body as any)).subscribe({\n                next: () => {\n                    notFavorite.forEach((selected) => (selected.entry.isFavorite = true));\n                    if (notFavorite.length > 1) {\n                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODES_ADDED', null, { number: notFavorite.length });\n                    } else {\n                        this.notificationService.showInfo('NODE_FAVORITE_DIRECTIVE.MESSAGES.NODE_ADDED', null, { name: notFavorite[0].entry.name });\n                    }\n                    this.toggle.emit();\n                },\n                error: (error) => this.error.emit(error)\n            });\n        }\n    }\n\n    markFavoritesNodes(selection: NodeEntry[]) {\n        if (selection.length <= this.favorites.length) {\n            this.favorites = this.reduce(this.favorites, selection);\n        }\n\n        const result = this.diff(selection, this.favorites);\n        const batch = this.getProcessBatch(result);\n\n        forkJoin(batch).subscribe((data) => {\n            this.favorites.push(...data);\n        });\n    }\n\n    hasFavorites(): boolean {\n        if (this.favorites && !this.favorites.length) {\n            return false;\n        }\n\n        return this.favorites.every((selected) => selected.entry.isFavorite);\n    }\n\n    private getProcessBatch(selection: NodeEntry[]): Observable<any>[] {\n        return selection.map((selected) => this.getFavorite(selected));\n    }\n\n    private getFavorite(selected: NodeEntry | SharedLinkEntry): Observable<any> {\n        const node: Node | SharedLink = selected.entry;\n\n        // ACS 6.x with 'isFavorite' include\n        if (node && Object.prototype.hasOwnProperty.call(node, 'isFavorite')) {\n            return of(selected);\n        }\n\n        // ACS 5.x and 6.x without 'isFavorite' include\n        const { name, isFile, isFolder } = node as Node;\n        const id = (node as SharedLink).nodeId || node.id;\n\n        const promise = this.favoritesApi.getFavorite('-me-', id);\n\n        return from(promise).pipe(\n            map(() => ({\n                entry: {\n                    id,\n                    isFolder,\n                    isFile,\n                    name,\n                    isFavorite: true\n                }\n            })),\n            catchError(() =>\n                of({\n                    entry: {\n                        id,\n                        isFolder,\n                        isFile,\n                        name,\n                        isFavorite: false\n                    }\n                })\n            )\n        );\n    }\n\n    private createFavoriteBody(node: NodeEntry): FavoriteBodyCreate {\n        const type = this.getNodeType(node);\n        // shared files have nodeId\n        const id = node.entry['nodeId'] || node.entry.id;\n\n        return {\n            target: {\n                [type]: {\n                    guid: id\n                }\n            }\n        };\n    }\n\n    private getNodeType(node: NodeEntry): string {\n        // shared could only be files\n        if (!node.entry.isFile && !node.entry.isFolder) {\n            return 'file';\n        }\n\n        return node.entry.isFile ? 'file' : 'folder';\n    }\n\n    private diff(list: NodeEntry[], patch: any[]): NodeEntry[] {\n        const ids = patch.map((item) => item.entry.id);\n\n        return list.filter((item) => (ids.includes(item.entry.id) ? null : item));\n    }\n\n    private reduce(patch: any[], comparator: NodeEntry[]): any[] {\n        const ids = comparator.map((item) => item.entry.id);\n\n        return patch.filter((item) => (ids.includes(item.entry.id) ? item : null));\n    }\n}\n"]}

package/esm2022/lib/directives/node-lock.directive.mjs

@@ -0,0 +1,57 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/no-input-rename */
+import { Directive, ElementRef, Renderer2, HostListener, Input } from '@angular/core';
+import { Node } from '@alfresco/js-api';
+import { ContentService } from '../common/services/content.service';
+import { AllowableOperationsEnum } from '../common/models/allowable-operations.enum';
+import { ContentNodeDialogService } from '../content-node-selector/content-node-dialog.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../common/services/content.service";
+import * as i2 from "../content-node-selector/content-node-dialog.service";
+export class NodeLockDirective {
+    onClick(event) {
+        event.stopPropagation();
+        this.contentNodeDialogService.openLockNodeDialog(this.node);
+    }
+    constructor(element, renderer, contentService, contentNodeDialogService) {
+        this.element = element;
+        this.renderer = renderer;
+        this.contentService = contentService;
+        this.contentNodeDialogService = contentNodeDialogService;
+    }
+    ngAfterViewInit() {
+        const hasAllowableOperations = this.contentService.hasAllowableOperations(this.node, AllowableOperationsEnum.LOCK);
+        this.renderer.setProperty(this.element.nativeElement, 'disabled', !hasAllowableOperations);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeLockDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ContentService }, { token: i2.ContentNodeDialogService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NodeLockDirective, isStandalone: true, selector: "[adf-node-lock]", inputs: { node: ["adf-node-lock", "node"] }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeLockDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[adf-node-lock]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ContentService }, { type: i2.ContentNodeDialogService }], propDecorators: { node: [{
+                type: Input,
+                args: ['adf-node-lock']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/node-restore.directive.mjs

@@ -0,0 +1,218 @@
+/*!
+ * @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.
+ */
+/* eslint-disable @angular-eslint/component-selector, @angular-eslint/no-input-rename */
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { TrashcanApi } from '@alfresco/js-api';
+import { forkJoin, from, of } from 'rxjs';
+import { tap, mergeMap, map, catchError } from 'rxjs/operators';
+import { TranslationService } from '@alfresco/adf-core';
+import { AlfrescoApiService } from '../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export class NodeRestoreDirective {
+    get trashcanApi() {
+        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.alfrescoApiService.getInstance());
+        return this._trashcanApi;
+    }
+    onClick() {
+        this.recover(this.selection);
+    }
+    constructor(alfrescoApiService, translation) {
+        this.alfrescoApiService = alfrescoApiService;
+        this.translation = translation;
+        /** Emitted when restoration is complete. */
+        this.restore = new EventEmitter();
+        this.restoreProcessStatus = this.processStatus();
+    }
+    recover(selection) {
+        if (!selection.length) {
+            return;
+        }
+        const nodesWithPath = this.getNodesWithPath(selection);
+        if (selection.length && nodesWithPath.length) {
+            this.restoreNodesBatch(nodesWithPath)
+                .pipe(tap((restoredNodes) => {
+                const status = this.processStatus(restoredNodes);
+                this.restoreProcessStatus.fail.push(...status.fail);
+                this.restoreProcessStatus.success.push(...status.success);
+            }), mergeMap(() => this.getDeletedNodes()))
+                .subscribe((deletedNodesList) => {
+                const { entries: nodeList } = deletedNodesList.list;
+                const { fail: restoreErrorNodes } = this.restoreProcessStatus;
+                const selectedNodes = this.diff(restoreErrorNodes, selection, false);
+                const remainingNodes = this.diff(selectedNodes, nodeList);
+                if (!remainingNodes.length) {
+                    this.notification();
+                }
+                else {
+                    this.recover(remainingNodes);
+                }
+            });
+        }
+        else {
+            this.restoreProcessStatus.fail.push(...selection);
+            this.notification();
+            return;
+        }
+    }
+    restoreNodesBatch(batch) {
+        return forkJoin(batch.map((node) => this.restoreNode(node)));
+    }
+    getNodesWithPath(selection) {
+        return selection.filter((node) => node.entry.path);
+    }
+    getDeletedNodes() {
+        const promise = this.trashcanApi.listDeletedNodes({ include: ['path'] });
+        return from(promise);
+    }
+    restoreNode(node) {
+        const { entry } = node;
+        const promise = this.trashcanApi.restoreDeletedNode(entry.id);
+        return from(promise).pipe(map(() => ({
+            status: 1,
+            entry
+        })), catchError((error) => {
+            const { statusCode } = JSON.parse(error.message).error;
+            return of({
+                status: 0,
+                statusCode,
+                entry
+            });
+        }));
+    }
+    diff(selection, list, fromList = true) {
+        const ids = selection.map((item) => item.entry.id);
+        return list.filter((item) => {
+            if (fromList) {
+                return ids.includes(item.entry.id) ? item : null;
+            }
+            else {
+                return !ids.includes(item.entry.id) ? item : null;
+            }
+        });
+    }
+    processStatus(data = []) {
+        const status = {
+            fail: [],
+            success: [],
+            get someFailed() {
+                return !!this.fail.length;
+            },
+            get someSucceeded() {
+                return !!this.success.length;
+            },
+            get oneFailed() {
+                return this.fail.length === 1;
+            },
+            get oneSucceeded() {
+                return this.success.length === 1;
+            },
+            get allSucceeded() {
+                return this.someSucceeded && !this.someFailed;
+            },
+            get allFailed() {
+                return this.someFailed && !this.someSucceeded;
+            },
+            reset() {
+                this.fail = [];
+                this.success = [];
+            }
+        };
+        return data.reduce((acc, node) => {
+            if (node.status) {
+                acc.success.push(node);
+            }
+            else {
+                acc.fail.push(node);
+            }
+            return acc;
+        }, status);
+    }
+    getRestoreMessage() {
+        const { restoreProcessStatus: status } = this;
+        if (status.someFailed && !status.oneFailed) {
+            return this.translation.instant('CORE.RESTORE_NODE.PARTIAL_PLURAL', {
+                // eslint-disable-next-line id-blacklist
+                number: status.fail.length
+            });
+        }
+        if (status.oneFailed && status.fail[0].statusCode) {
+            if (status.fail[0].statusCode === 409) {
+                return this.translation.instant('CORE.RESTORE_NODE.NODE_EXISTS', {
+                    name: status.fail[0].entry.name
+                });
+            }
+            else {
+                return this.translation.instant('CORE.RESTORE_NODE.GENERIC', {
+                    name: status.fail[0].entry.name
+                });
+            }
+        }
+        if (status.oneFailed && !status.fail[0].statusCode) {
+            return this.translation.instant('CORE.RESTORE_NODE.LOCATION_MISSING', {
+                name: status.fail[0].entry.name
+            });
+        }
+        if (status.allSucceeded && !status.oneSucceeded) {
+            return this.translation.instant('CORE.RESTORE_NODE.PLURAL');
+        }
+        if (status.allSucceeded && status.oneSucceeded) {
+            return this.translation.instant('CORE.RESTORE_NODE.SINGULAR', {
+                name: status.success[0].entry.name
+            });
+        }
+        return null;
+    }
+    notification() {
+        const status = Object.assign({}, this.restoreProcessStatus);
+        const message = this.getRestoreMessage();
+        this.reset();
+        const action = status.oneSucceeded && !status.someFailed ? this.translation.instant('CORE.RESTORE_NODE.VIEW') : '';
+        let path;
+        if (status.success && status.success.length > 0) {
+            path = status.success[0].entry.path;
+        }
+        this.restore.emit({
+            message,
+            action,
+            path
+        });
+    }
+    reset() {
+        this.restoreProcessStatus.reset();
+        this.selection = [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeRestoreDirective, deps: [{ token: i1.AlfrescoApiService }, { token: i2.TranslationService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NodeRestoreDirective, isStandalone: true, selector: "[adf-restore]", inputs: { selection: ["adf-restore", "selection"] }, outputs: { restore: "restore" }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeRestoreDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[adf-restore]'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.TranslationService }], propDecorators: { selection: [{
+                type: Input,
+                args: ['adf-restore']
+            }], restore: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-restore.directive.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/directives/node-restore.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\n/* eslint-disable @angular-eslint/component-selector, @angular-eslint/no-input-rename */\n\nimport { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';\nimport { TrashcanApi, DeletedNodeEntry, DeletedNodesPaging } from '@alfresco/js-api';\nimport { Observable, forkJoin, from, of } from 'rxjs';\nimport { tap, mergeMap, map, catchError } from 'rxjs/operators';\nimport { TranslationService } from '@alfresco/adf-core';\nimport { RestoreMessageModel } from '../interfaces/restore-message-model.interface';\nimport { AlfrescoApiService } from '../services/alfresco-api.service';\n\n@Directive({\n    standalone: true,\n    selector: '[adf-restore]'\n})\nexport class NodeRestoreDirective {\n    private readonly restoreProcessStatus;\n\n    private _trashcanApi: TrashcanApi;\n    get trashcanApi(): TrashcanApi {\n        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.alfrescoApiService.getInstance());\n        return this._trashcanApi;\n    }\n\n    /** Array of deleted nodes to restore. */\n    @Input('adf-restore')\n    selection: DeletedNodeEntry[];\n\n    /** Emitted when restoration is complete. */\n    @Output()\n    restore: EventEmitter<RestoreMessageModel> = new EventEmitter();\n\n    @HostListener('click')\n    onClick() {\n        this.recover(this.selection);\n    }\n\n    constructor(private alfrescoApiService: AlfrescoApiService, private translation: TranslationService) {\n        this.restoreProcessStatus = this.processStatus();\n    }\n\n    private recover(selection: any) {\n        if (!selection.length) {\n            return;\n        }\n\n        const nodesWithPath = this.getNodesWithPath(selection);\n\n        if (selection.length && nodesWithPath.length) {\n            this.restoreNodesBatch(nodesWithPath)\n                .pipe(\n                    tap((restoredNodes) => {\n                        const status = this.processStatus(restoredNodes);\n\n                        this.restoreProcessStatus.fail.push(...status.fail);\n                        this.restoreProcessStatus.success.push(...status.success);\n                    }),\n                    mergeMap(() => this.getDeletedNodes())\n                )\n                .subscribe((deletedNodesList) => {\n                    const { entries: nodeList } = deletedNodesList.list;\n                    const { fail: restoreErrorNodes } = this.restoreProcessStatus;\n                    const selectedNodes = this.diff(restoreErrorNodes, selection, false);\n                    const remainingNodes = this.diff(selectedNodes, nodeList);\n\n                    if (!remainingNodes.length) {\n                        this.notification();\n                    } else {\n                        this.recover(remainingNodes);\n                    }\n                });\n        } else {\n            this.restoreProcessStatus.fail.push(...selection);\n            this.notification();\n            return;\n        }\n    }\n\n    private restoreNodesBatch(batch: DeletedNodeEntry[]): Observable<DeletedNodeEntry[]> {\n        return forkJoin(batch.map((node) => this.restoreNode(node)));\n    }\n\n    private getNodesWithPath(selection): DeletedNodeEntry[] {\n        return selection.filter((node) => node.entry.path);\n    }\n\n    private getDeletedNodes(): Observable<DeletedNodesPaging> {\n        const promise = this.trashcanApi.listDeletedNodes({ include: ['path'] });\n\n        return from(promise);\n    }\n\n    private restoreNode(node): Observable<any> {\n        const { entry } = node;\n\n        const promise = this.trashcanApi.restoreDeletedNode(entry.id);\n\n        return from(promise).pipe(\n            map(() => ({\n                status: 1,\n                entry\n            })),\n            catchError((error) => {\n                const { statusCode } = JSON.parse(error.message).error;\n\n                return of({\n                    status: 0,\n                    statusCode,\n                    entry\n                });\n            })\n        );\n    }\n\n    private diff(selection, list, fromList = true): any {\n        const ids = selection.map((item) => item.entry.id);\n\n        return list.filter((item) => {\n            if (fromList) {\n                return ids.includes(item.entry.id) ? item : null;\n            } else {\n                return !ids.includes(item.entry.id) ? item : null;\n            }\n        });\n    }\n\n    private processStatus(data = []): any {\n        const status = {\n            fail: [],\n            success: [],\n            get someFailed() {\n                return !!this.fail.length;\n            },\n            get someSucceeded() {\n                return !!this.success.length;\n            },\n            get oneFailed() {\n                return this.fail.length === 1;\n            },\n            get oneSucceeded() {\n                return this.success.length === 1;\n            },\n            get allSucceeded() {\n                return this.someSucceeded && !this.someFailed;\n            },\n            get allFailed() {\n                return this.someFailed && !this.someSucceeded;\n            },\n            reset() {\n                this.fail = [];\n                this.success = [];\n            }\n        };\n\n        return data.reduce((acc, node) => {\n            if (node.status) {\n                acc.success.push(node);\n            } else {\n                acc.fail.push(node);\n            }\n\n            return acc;\n        }, status);\n    }\n\n    private getRestoreMessage(): string | null {\n        const { restoreProcessStatus: status } = this;\n\n        if (status.someFailed && !status.oneFailed) {\n            return this.translation.instant('CORE.RESTORE_NODE.PARTIAL_PLURAL', {\n                // eslint-disable-next-line id-blacklist\n                number: status.fail.length\n            });\n        }\n\n        if (status.oneFailed && status.fail[0].statusCode) {\n            if (status.fail[0].statusCode === 409) {\n                return this.translation.instant('CORE.RESTORE_NODE.NODE_EXISTS', {\n                    name: status.fail[0].entry.name\n                });\n            } else {\n                return this.translation.instant('CORE.RESTORE_NODE.GENERIC', {\n                    name: status.fail[0].entry.name\n                });\n            }\n        }\n\n        if (status.oneFailed && !status.fail[0].statusCode) {\n            return this.translation.instant('CORE.RESTORE_NODE.LOCATION_MISSING', {\n                name: status.fail[0].entry.name\n            });\n        }\n\n        if (status.allSucceeded && !status.oneSucceeded) {\n            return this.translation.instant('CORE.RESTORE_NODE.PLURAL');\n        }\n\n        if (status.allSucceeded && status.oneSucceeded) {\n            return this.translation.instant('CORE.RESTORE_NODE.SINGULAR', {\n                name: status.success[0].entry.name\n            });\n        }\n\n        return null;\n    }\n\n    private notification(): void {\n        const status = Object.assign({}, this.restoreProcessStatus);\n\n        const message = this.getRestoreMessage();\n        this.reset();\n\n        const action = status.oneSucceeded && !status.someFailed ? this.translation.instant('CORE.RESTORE_NODE.VIEW') : '';\n\n        let path;\n        if (status.success && status.success.length > 0) {\n            path = status.success[0].entry.path;\n        }\n        this.restore.emit({\n            message,\n            action,\n            path\n        });\n    }\n\n    private reset(): void {\n        this.restoreProcessStatus.reset();\n        this.selection = [];\n    }\n}\n"]}

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

@@ -0,0 +1,28 @@
+/*!
+ * @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 './content-directive.module';
+export * from './node-lock.directive';
+export * from './node-counter.directive';
+export * from './auto-focus.directive';
+export * from './check-allowable-operation.directive';
+export * from './library-favorite.directive';
+export * from './library-membership.directive';
+export * from './node-delete.directive';
+export * from './node-favorite.directive';
+export * from './node-restore.directive';
+export * from './node-download.directive';
+//# sourceMappingURL=data:application/json;base64,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