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

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

@@ -0,0 +1,59 @@
+/*!
+ * @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 { Directive, Input, Component, ViewContainerRef } from '@angular/core';
+import { TranslatePipe } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export class NodeCounterDirective {
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+    }
+    ngOnInit() {
+        this.componentRef = this.viewContainerRef.createComponent(NodeCounterComponent).instance;
+        this.componentRef.counter = this.counter;
+    }
+    ngOnChanges() {
+        if (this.componentRef) {
+            this.componentRef.counter = this.counter;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeCounterDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NodeCounterDirective, isStandalone: true, selector: "[adf-node-counter]", inputs: { counter: ["adf-node-counter", "counter"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeCounterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[adf-node-counter]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }], propDecorators: { counter: [{
+                type: Input,
+                args: ['adf-node-counter']
+            }] } });
+export class NodeCounterComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeCounterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: NodeCounterComponent, isStandalone: true, selector: "adf-node-counter", ngImport: i0, template: ` <div>{{ 'NODE_COUNTER.SELECTED_COUNT' | translate : { count: counter } }}</div> `, isInline: true, dependencies: [{ kind: "pipe", type: TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeCounterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [TranslatePipe],
+                    selector: 'adf-node-counter',
+                    template: ` <div>{{ 'NODE_COUNTER.SELECTED_COUNT' | translate : { count: counter } }}</div> `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,177 @@
+/*!
+ * @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, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { TrashcanApi, NodesApi } from '@alfresco/js-api';
+import { forkJoin, from, of } from 'rxjs';
+import { TranslationService } from '@alfresco/adf-core';
+import { map, catchError, retry } from 'rxjs/operators';
+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 NodeDeleteDirective {
+    get trashcanApi() {
+        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.alfrescoApiService.getInstance());
+        return this._trashcanApi;
+    }
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.alfrescoApiService.getInstance());
+        return this._nodesApi;
+    }
+    onClick() {
+        this.process(this.selection);
+    }
+    constructor(alfrescoApiService, translation, elementRef) {
+        this.alfrescoApiService = alfrescoApiService;
+        this.translation = translation;
+        this.elementRef = elementRef;
+        /** If true then the nodes are deleted immediately rather than being put in the trash */
+        this.permanent = false;
+        /** Emitted when the nodes have been deleted. */
+        this.delete = new EventEmitter();
+    }
+    ngOnChanges() {
+        if (!this.selection || (this.selection && this.selection.length === 0)) {
+            this.setDisableAttribute(true);
+        }
+        else {
+            if (!this.elementRef.nativeElement.hasAttribute('adf-check-allowable-operation')) {
+                this.setDisableAttribute(false);
+            }
+        }
+    }
+    setDisableAttribute(disable) {
+        this.elementRef.nativeElement.disabled = disable;
+    }
+    process(selection) {
+        if (selection?.length) {
+            const batch = this.getDeleteNodesBatch(selection);
+            forkJoin(...batch).subscribe((data) => {
+                const processedItems = this.processStatus(data);
+                const message = this.getMessage(processedItems);
+                if (message) {
+                    this.delete.emit(message);
+                }
+            });
+        }
+    }
+    getDeleteNodesBatch(selection) {
+        return selection.map((node) => this.deleteNode(node));
+    }
+    deleteNode(node) {
+        const id = node.entry.nodeId || node.entry.id;
+        let promise;
+        if (Object.prototype.hasOwnProperty.call(node.entry, 'archivedAt') && node.entry['archivedAt']) {
+            promise = this.trashcanApi.deleteDeletedNode(id);
+        }
+        else {
+            promise = this.nodesApi.deleteNode(id, { permanent: this.permanent });
+        }
+        return from(promise).pipe(retry(3), map(() => ({
+            entry: node.entry,
+            status: 1
+        })), catchError(() => of({
+            entry: node.entry,
+            status: 0
+        })));
+    }
+    processStatus(data) {
+        const deleteStatus = {
+            success: [],
+            failed: [],
+            get someFailed() {
+                return !!this.failed.length;
+            },
+            get someSucceeded() {
+                return !!this.success.length;
+            },
+            get oneFailed() {
+                return this.failed.length === 1;
+            },
+            get oneSucceeded() {
+                return this.success.length === 1;
+            },
+            get allSucceeded() {
+                return this.someSucceeded && !this.someFailed;
+            },
+            get allFailed() {
+                return this.someFailed && !this.someSucceeded;
+            }
+        };
+        return data.reduce((acc, next) => {
+            if (next.status === 1) {
+                acc.success.push(next);
+            }
+            else {
+                acc.failed.push(next);
+            }
+            return acc;
+        }, deleteStatus);
+    }
+    getMessage(status) {
+        if (status.allFailed && !status.oneFailed) {
+            return this.translation.instant('CORE.DELETE_NODE.ERROR_PLURAL', 
+            // eslint-disable-next-line id-blacklist
+            { number: status.failed.length });
+        }
+        if (status.allSucceeded && !status.oneSucceeded) {
+            return this.translation.instant('CORE.DELETE_NODE.PLURAL', 
+            // eslint-disable-next-line id-blacklist
+            { number: status.success.length });
+        }
+        if (status.someFailed && status.someSucceeded && !status.oneSucceeded) {
+            return this.translation.instant('CORE.DELETE_NODE.PARTIAL_PLURAL', {
+                success: status.success.length,
+                failed: status.failed.length
+            });
+        }
+        if (status.someFailed && status.oneSucceeded) {
+            return this.translation.instant('CORE.DELETE_NODE.PARTIAL_SINGULAR', {
+                success: status.success.length,
+                failed: status.failed.length
+            });
+        }
+        if (status.oneFailed && !status.someSucceeded) {
+            return this.translation.instant('CORE.DELETE_NODE.ERROR_SINGULAR', { name: status.failed[0].entry.name });
+        }
+        if (status.oneSucceeded && !status.someFailed) {
+            return this.translation.instant('CORE.DELETE_NODE.SINGULAR', { name: status.success[0].entry.name });
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeDeleteDirective, deps: [{ token: i1.AlfrescoApiService }, { token: i2.TranslationService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NodeDeleteDirective, isStandalone: true, selector: "[adf-delete]", inputs: { selection: ["adf-delete", "selection"], permanent: "permanent" }, outputs: { delete: "delete" }, host: { listeners: { "click": "onClick()" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeDeleteDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[adf-delete]'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.TranslationService }, { type: i0.ElementRef }], propDecorators: { selection: [{
+                type: Input,
+                args: ['adf-delete']
+            }], permanent: [{
+                type: Input
+            }], delete: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-delete.directive.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/directives/node-delete.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, ElementRef, EventEmitter, HostListener, Input, OnChanges, Output } from '@angular/core';\nimport { NodeEntry, Node, DeletedNodeEntry, DeletedNode, TrashcanApi, NodesApi } from '@alfresco/js-api';\nimport { Observable, forkJoin, from, of } from 'rxjs';\nimport { TranslationService } from '@alfresco/adf-core';\nimport { map, catchError, retry } from 'rxjs/operators';\nimport { AlfrescoApiService } from '../services/alfresco-api.service';\n\ninterface ProcessedNodeData {\n    entry: Node | DeletedNode;\n    status: number;\n}\n\ninterface ProcessStatus {\n    success: ProcessedNodeData[];\n    failed: ProcessedNodeData[];\n\n    someFailed();\n\n    someSucceeded();\n\n    oneFailed();\n\n    oneSucceeded();\n\n    allSucceeded();\n\n    allFailed();\n}\n\n@Directive({\n    standalone: true,\n    selector: '[adf-delete]'\n})\nexport class NodeDeleteDirective implements OnChanges {\n    /** Array of nodes to delete. */\n    @Input('adf-delete')\n    selection: NodeEntry[] | DeletedNodeEntry[];\n\n    /** If true then the nodes are deleted immediately rather than being put in the trash */\n    @Input()\n    permanent: boolean = false;\n\n    /** Emitted when the nodes have been deleted. */\n    @Output()\n    delete: EventEmitter<any> = new EventEmitter();\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    private _nodesApi: NodesApi;\n    get nodesApi(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.alfrescoApiService.getInstance());\n        return this._nodesApi;\n    }\n\n    @HostListener('click')\n    onClick() {\n        this.process(this.selection);\n    }\n\n    constructor(private alfrescoApiService: AlfrescoApiService, private translation: TranslationService, private elementRef: ElementRef) {}\n\n    ngOnChanges() {\n        if (!this.selection || (this.selection && this.selection.length === 0)) {\n            this.setDisableAttribute(true);\n        } else {\n            if (!this.elementRef.nativeElement.hasAttribute('adf-check-allowable-operation')) {\n                this.setDisableAttribute(false);\n            }\n        }\n    }\n\n    private setDisableAttribute(disable: boolean) {\n        this.elementRef.nativeElement.disabled = disable;\n    }\n\n    private process(selection: NodeEntry[] | DeletedNodeEntry[]) {\n        if (selection?.length) {\n            const batch = this.getDeleteNodesBatch(selection);\n\n            forkJoin(...batch).subscribe((data: ProcessedNodeData[]) => {\n                const processedItems: ProcessStatus = this.processStatus(data);\n                const message = this.getMessage(processedItems);\n\n                if (message) {\n                    this.delete.emit(message);\n                }\n            });\n        }\n    }\n\n    private getDeleteNodesBatch(selection: NodeEntry[] | DeletedNodeEntry[]): Observable<ProcessedNodeData>[] {\n        return selection.map((node) => this.deleteNode(node));\n    }\n\n    private deleteNode(node: NodeEntry | DeletedNodeEntry): Observable<ProcessedNodeData> {\n        const id = (node.entry as any).nodeId || node.entry.id;\n\n        let promise: Promise<any>;\n\n        if (Object.prototype.hasOwnProperty.call(node.entry, 'archivedAt') && node.entry['archivedAt']) {\n            promise = this.trashcanApi.deleteDeletedNode(id);\n        } else {\n            promise = this.nodesApi.deleteNode(id, { permanent: this.permanent });\n        }\n\n        return from(promise).pipe(\n            retry(3),\n            map(() => ({\n                entry: node.entry,\n                status: 1\n            })),\n            catchError(() =>\n                of({\n                    entry: node.entry,\n                    status: 0\n                })\n            )\n        );\n    }\n\n    private processStatus(data): ProcessStatus {\n        const deleteStatus = {\n            success: [],\n            failed: [],\n            get someFailed() {\n                return !!this.failed.length;\n            },\n            get someSucceeded() {\n                return !!this.success.length;\n            },\n            get oneFailed() {\n                return this.failed.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        };\n\n        return data.reduce((acc, next) => {\n            if (next.status === 1) {\n                acc.success.push(next);\n            } else {\n                acc.failed.push(next);\n            }\n\n            return acc;\n        }, deleteStatus);\n    }\n\n    private getMessage(status: ProcessStatus): string | null {\n        if (status.allFailed && !status.oneFailed) {\n            return this.translation.instant(\n                'CORE.DELETE_NODE.ERROR_PLURAL',\n                // eslint-disable-next-line id-blacklist\n                { number: status.failed.length }\n            );\n        }\n\n        if (status.allSucceeded && !status.oneSucceeded) {\n            return this.translation.instant(\n                'CORE.DELETE_NODE.PLURAL',\n                // eslint-disable-next-line id-blacklist\n                { number: status.success.length }\n            );\n        }\n\n        if (status.someFailed && status.someSucceeded && !status.oneSucceeded) {\n            return this.translation.instant('CORE.DELETE_NODE.PARTIAL_PLURAL', {\n                success: status.success.length,\n                failed: status.failed.length\n            });\n        }\n\n        if (status.someFailed && status.oneSucceeded) {\n            return this.translation.instant('CORE.DELETE_NODE.PARTIAL_SINGULAR', {\n                success: status.success.length,\n                failed: status.failed.length\n            });\n        }\n\n        if (status.oneFailed && !status.someSucceeded) {\n            return this.translation.instant('CORE.DELETE_NODE.ERROR_SINGULAR', { name: status.failed[0].entry.name });\n        }\n\n        if (status.oneSucceeded && !status.someFailed) {\n            return this.translation.instant('CORE.DELETE_NODE.SINGULAR', { name: status.success[0].entry.name });\n        }\n\n        return null;\n    }\n}\n"]}

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

@@ -0,0 +1,138 @@
+/*!
+ * @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 { Directive, Input, HostListener } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { DownloadService } from '@alfresco/adf-core';
+import { DownloadZipDialogComponent } from '../dialogs/download-zip/download-zip.dialog';
+import { ContentApi, VersionEntry } from '@alfresco/js-api';
+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";
+import * as i3 from "@angular/material/dialog";
+/**
+ * Directive selectors without adf- prefix will be deprecated on 3.0.0
+ */
+export class NodeDownloadDirective {
+    get contentApi() {
+        this._contentApi = this._contentApi ?? new ContentApi(this.apiService.getInstance());
+        return this._contentApi;
+    }
+    onClick() {
+        this.downloadNodes(this.nodes);
+    }
+    constructor(apiService, downloadService, dialog) {
+        this.apiService = apiService;
+        this.downloadService = downloadService;
+        this.dialog = dialog;
+    }
+    /**
+     * Downloads multiple selected nodes.
+     * Packs result into a .ZIP archive if there is more than one node selected.
+     *
+     * @param selection Multiple selected nodes to download
+     */
+    downloadNodes(selection) {
+        if (!this.isSelectionValid(selection)) {
+            return;
+        }
+        if (selection instanceof Array) {
+            if (selection.length === 1) {
+                this.downloadNode(selection[0]);
+            }
+            else {
+                this.downloadZip(selection);
+            }
+        }
+        else {
+            this.downloadNode(selection);
+        }
+    }
+    /**
+     * Downloads a single node.
+     * Packs result into a .ZIP archive is the node is a Folder.
+     *
+     * @param node Node to download
+     */
+    downloadNode(node) {
+        if (node?.entry) {
+            const entry = node.entry;
+            if (entry.isFile) {
+                this.downloadFile(node);
+            }
+            if (entry.isFolder) {
+                this.downloadZip([node]);
+            }
+            // Check if there's nodeId for Shared Files
+            if (!entry.isFile && !entry.isFolder && entry.nodeId) {
+                this.downloadFile(node);
+            }
+        }
+    }
+    isSelectionValid(selection) {
+        return selection || (selection instanceof Array && selection.length > 0);
+    }
+    downloadFile(node) {
+        if (node?.entry) {
+            // nodeId for Shared node
+            const id = node.entry.nodeId || node.entry.id;
+            let url;
+            let fileName;
+            if (this.version) {
+                url = this.contentApi.getVersionContentUrl(id, this.version.entry.id, true);
+                fileName = this.version.entry.name;
+            }
+            else {
+                url = this.contentApi.getContentUrl(id, true);
+                fileName = node.entry.name;
+            }
+            this.downloadService.downloadUrl(url, fileName);
+        }
+    }
+    downloadZip(selection) {
+        if (selection && selection.length > 0) {
+            // nodeId for Shared node
+            const nodeIds = selection.map((node) => node.entry.nodeId || node.entry.id);
+            this.dialog.open(DownloadZipDialogComponent, {
+                width: '600px',
+                disableClose: true,
+                data: {
+                    nodeIds
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeDownloadDirective, deps: [{ token: i1.AlfrescoApiService }, { token: i2.DownloadService }, { token: i3.MatDialog }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NodeDownloadDirective, isStandalone: true, selector: "[adfNodeDownload]", inputs: { nodes: ["adfNodeDownload", "nodes"], version: "version" }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeDownloadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[adfNodeDownload]'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.DownloadService }, { type: i3.MatDialog }], propDecorators: { nodes: [{
+                type: Input,
+                args: ['adfNodeDownload']
+            }], version: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-download.directive.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/directives/node-download.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 { Directive, Input, HostListener } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { DownloadService } from '@alfresco/adf-core';\nimport { DownloadZipDialogComponent } from '../dialogs/download-zip/download-zip.dialog';\nimport { ContentApi, NodeEntry, VersionEntry } from '@alfresco/js-api';\nimport { AlfrescoApiService } from '../services/alfresco-api.service';\n\n/**\n * Directive selectors without adf- prefix will be deprecated on 3.0.0\n */\n@Directive({\n    standalone: true,\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: '[adfNodeDownload]'\n})\nexport class NodeDownloadDirective {\n    private _contentApi: ContentApi;\n    get contentApi(): ContentApi {\n        this._contentApi = this._contentApi ?? new ContentApi(this.apiService.getInstance());\n        return this._contentApi;\n    }\n\n    /** Nodes to download. */\n    @Input('adfNodeDownload')\n    nodes: NodeEntry | NodeEntry[];\n\n    /** Node's version to download. */\n    @Input()\n    version: VersionEntry;\n\n    @HostListener('click')\n    onClick() {\n        this.downloadNodes(this.nodes);\n    }\n\n    constructor(private apiService: AlfrescoApiService, private downloadService: DownloadService, private dialog: MatDialog) {}\n\n    /**\n     * Downloads multiple selected nodes.\n     * Packs result into a .ZIP archive if there is more than one node selected.\n     *\n     * @param selection Multiple selected nodes to download\n     */\n    downloadNodes(selection: NodeEntry | Array<NodeEntry>) {\n        if (!this.isSelectionValid(selection)) {\n            return;\n        }\n        if (selection instanceof Array) {\n            if (selection.length === 1) {\n                this.downloadNode(selection[0]);\n            } else {\n                this.downloadZip(selection);\n            }\n        } else {\n            this.downloadNode(selection);\n        }\n    }\n\n    /**\n     * Downloads a single node.\n     * Packs result into a .ZIP archive is the node is a Folder.\n     *\n     * @param node Node to download\n     */\n    downloadNode(node: NodeEntry) {\n        if (node?.entry) {\n            const entry = node.entry;\n\n            if (entry.isFile) {\n                this.downloadFile(node);\n            }\n\n            if (entry.isFolder) {\n                this.downloadZip([node]);\n            }\n\n            // Check if there's nodeId for Shared Files\n            if (!entry.isFile && !entry.isFolder && (entry as any).nodeId) {\n                this.downloadFile(node);\n            }\n        }\n    }\n\n    private isSelectionValid(selection: NodeEntry | Array<NodeEntry>) {\n        return selection || (selection instanceof Array && selection.length > 0);\n    }\n\n    private downloadFile(node: NodeEntry) {\n        if (node?.entry) {\n            // nodeId for Shared node\n            const id = (node.entry as any).nodeId || node.entry.id;\n\n            let url: string;\n            let fileName: string;\n            if (this.version) {\n                url = this.contentApi.getVersionContentUrl(id, this.version.entry.id, true);\n                fileName = this.version.entry.name;\n            } else {\n                url = this.contentApi.getContentUrl(id, true);\n                fileName = node.entry.name;\n            }\n\n            this.downloadService.downloadUrl(url, fileName);\n        }\n    }\n\n    private downloadZip(selection: Array<NodeEntry>) {\n        if (selection && selection.length > 0) {\n            // nodeId for Shared node\n            const nodeIds = selection.map((node: any) => node.entry.nodeId || node.entry.id);\n\n            this.dialog.open(DownloadZipDialogComponent, {\n                width: '600px',\n                disableClose: true,\n                data: {\n                    nodeIds\n                }\n            });\n        }\n    }\n}\n"]}