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

package/esm2022/lib/document-list/services/document-list.service.mjs

@@ -0,0 +1,175 @@
+import { NodesApiService } from '../../common/services/nodes-api.service';
+import { inject, Injectable } from '@angular/core';
+import { NodesApi } from '@alfresco/js-api';
+import { DocumentLoaderNode } from '../models/document-folder.model';
+import { from, forkJoin, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { CustomResourcesService } from './custom-resources.service';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+const ROOT_ID = '-root-';
+export class DocumentListService {
+    constructor() {
+        this.nodesApiService = inject(NodesApiService);
+        this.apiService = inject(AlfrescoApiService);
+        this.customResourcesService = inject(CustomResourcesService);
+        this._reload = new Subject();
+        this._resetSelection = new Subject();
+        /** Gets an observable that emits when the document list should be reloaded. */
+        this.reload$ = this._reload.asObservable();
+        /** Gets an observable that emits when the selection should be reset. */
+        this.resetSelection$ = this._resetSelection.asObservable();
+    }
+    get nodes() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    /** Reloads the document list. */
+    reload() {
+        this._reload.next();
+    }
+    /** Resets the selection. */
+    resetSelection() {
+        this._resetSelection.next();
+    }
+    /**
+     * Deletes a node.
+     *
+     * @param nodeId ID of the node to delete
+     * @returns Empty response when the operation is complete
+     */
+    deleteNode(nodeId) {
+        return from(this.nodes.deleteNode(nodeId));
+    }
+    /**
+     * Copy a node to destination node
+     *
+     * @param nodeId The id of the node to be copied
+     * @param targetParentId The id of the folder where the node will be copied
+     * @returns NodeEntry for the copied node
+     */
+    copyNode(nodeId, targetParentId) {
+        return from(this.nodes.copyNode(nodeId, { targetParentId }));
+    }
+    /**
+     * Moves a node to destination node.
+     *
+     * @param nodeId The id of the node to be moved
+     * @param targetParentId The id of the folder where the node will be moved
+     * @returns NodeEntry for the moved node
+     */
+    moveNode(nodeId, targetParentId) {
+        return from(this.nodes.moveNode(nodeId, { targetParentId }));
+    }
+    /**
+     * Gets the folder node with the specified relative name path below the root node.
+     *
+     * @param folder Path to folder.
+     * @param opts Options.
+     * @param includeFields Extra information to include (available options are "aspectNames", "isLink" and "association")
+     * @returns Details of the folder
+     */
+    getFolder(folder, opts, includeFields = []) {
+        let rootNodeId = ROOT_ID;
+        if (opts?.rootFolderId) {
+            rootNodeId = opts.rootFolderId;
+        }
+        const includeFieldsRequest = ['path', 'properties', 'allowableOperations', 'permissions', 'aspectNames', ...includeFields].filter((element, index, array) => index === array.indexOf(element));
+        const params = {
+            includeSource: true,
+            include: includeFieldsRequest
+        };
+        if (folder) {
+            params.relativePath = folder;
+        }
+        if (opts) {
+            if (opts.maxItems) {
+                params.maxItems = opts.maxItems;
+            }
+            if (opts.skipCount) {
+                params.skipCount = opts.skipCount;
+            }
+            if (opts.where) {
+                params.where = opts.where;
+            }
+            if (opts.orderBy) {
+                params.orderBy = opts.orderBy;
+            }
+        }
+        return from(this.nodes.listNodeChildren(rootNodeId, params));
+    }
+    /**
+     * Gets a node via its node ID.
+     *
+     * @param nodeId ID of the target node
+     * @param includeFields Extra information to include (available options are "aspectNames", "isLink" and "association")
+     * @returns Details of the folder
+     */
+    getNode(nodeId, includeFields = []) {
+        const includeFieldsRequest = ['path', 'properties', 'allowableOperations', 'permissions', 'definition', ...includeFields].filter((element, index, array) => index === array.indexOf(element));
+        const opts = {
+            includeSource: true,
+            include: includeFieldsRequest
+        };
+        return this.nodesApiService.getNode(nodeId, opts);
+    }
+    /**
+     * Gets a folder node via its node ID.
+     *
+     * @param nodeId ID of the folder node
+     * @param includeFields Extra information to include (available options are "aspectNames", "isLink" and "association")
+     * @returns Details of the folder
+     */
+    getFolderNode(nodeId, includeFields = []) {
+        const includeFieldsRequest = ['path', 'properties', 'allowableOperations', 'permissions', 'aspectNames', ...includeFields].filter((element, index, array) => index === array.indexOf(element));
+        const opts = {
+            includeSource: true,
+            include: includeFieldsRequest
+        };
+        return from(this.nodes.getNode(nodeId, opts));
+    }
+    isCustomSourceService(nodeId) {
+        return this.customResourcesService.isCustomSource(nodeId);
+    }
+    /**
+     * Load a folder by Node Id.
+     *
+     * @param nodeId ID of the folder node
+     * @param pagination pagination model
+     * @param includeFields List of data field names to include in the results
+     * @param where  Optionally filter the list
+     * @param orderBy order by node property
+     * @returns Details of the folder
+     */
+    loadFolderByNodeId(nodeId, pagination, includeFields, where, orderBy) {
+        if (this.customResourcesService.isCustomSource(nodeId)) {
+            return this.customResourcesService
+                .loadFolderByNodeId(nodeId, pagination, includeFields, where)
+                .pipe(map((result) => new DocumentLoaderNode(null, result)));
+        }
+        else {
+            return this.retrieveDocumentNode(nodeId, pagination, includeFields, where, orderBy);
+        }
+    }
+    retrieveDocumentNode(nodeId, pagination, includeFields, where, orderBy) {
+        return forkJoin([
+            this.getFolderNode(nodeId, includeFields),
+            this.getFolder(null, {
+                maxItems: pagination.maxItems,
+                skipCount: pagination.skipCount,
+                orderBy,
+                rootFolderId: nodeId,
+                where
+            }, includeFields)
+        ]).pipe(map((results) => new DocumentLoaderNode(results[0], results[1])));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-list.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/services/document-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 { PaginationModel } from '@alfresco/adf-core';\nimport { NodesApiService } from '../../common/services/nodes-api.service';\nimport { inject, Injectable } from '@angular/core';\nimport { Node, NodeEntry, NodePaging, NodesApi } from '@alfresco/js-api';\nimport { DocumentLoaderNode } from '../models/document-folder.model';\nimport { Observable, from, forkJoin, Subject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { DocumentListLoader } from '../interfaces/document-list-loader.interface';\nimport { CustomResourcesService } from './custom-resources.service';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\nconst ROOT_ID = '-root-';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class DocumentListService implements DocumentListLoader {\n    private nodesApiService = inject(NodesApiService);\n    private apiService = inject(AlfrescoApiService);\n    private customResourcesService = inject(CustomResourcesService);\n\n    private _nodesApi: NodesApi;\n    get nodes(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());\n        return this._nodesApi;\n    }\n\n    private _reload = new Subject<void>();\n    private _resetSelection = new Subject<void>();\n\n    /** Gets an observable that emits when the document list should be reloaded. */\n    reload$ = this._reload.asObservable();\n\n    /** Gets an observable that emits when the selection should be reset. */\n    resetSelection$ = this._resetSelection.asObservable();\n\n    /** Reloads the document list. */\n    reload() {\n        this._reload.next();\n    }\n\n    /** Resets the selection. */\n    resetSelection() {\n        this._resetSelection.next();\n    }\n\n    /**\n     * Deletes a node.\n     *\n     * @param nodeId ID of the node to delete\n     * @returns Empty response when the operation is complete\n     */\n    deleteNode(nodeId: string): Observable<any> {\n        return from(this.nodes.deleteNode(nodeId));\n    }\n\n    /**\n     * Copy a node to destination node\n     *\n     * @param nodeId The id of the node to be copied\n     * @param targetParentId The id of the folder where the node will be copied\n     * @returns NodeEntry for the copied node\n     */\n    copyNode(nodeId: string, targetParentId: string): Observable<NodeEntry> {\n        return from(this.nodes.copyNode(nodeId, { targetParentId }));\n    }\n\n    /**\n     * Moves a node to destination node.\n     *\n     * @param nodeId The id of the node to be moved\n     * @param targetParentId The id of the folder where the node will be moved\n     * @returns NodeEntry for the moved node\n     */\n    moveNode(nodeId: string, targetParentId: string): Observable<NodeEntry> {\n        return from(this.nodes.moveNode(nodeId, { targetParentId }));\n    }\n\n    /**\n     * Gets the folder node with the specified relative name path below the root node.\n     *\n     * @param folder Path to folder.\n     * @param opts Options.\n     * @param includeFields Extra information to include (available options are \"aspectNames\", \"isLink\" and \"association\")\n     * @returns Details of the folder\n     */\n    getFolder(folder: string, opts?: any, includeFields: string[] = []): Observable<NodePaging> {\n        let rootNodeId = ROOT_ID;\n        if (opts?.rootFolderId) {\n            rootNodeId = opts.rootFolderId;\n        }\n\n        const includeFieldsRequest = ['path', 'properties', 'allowableOperations', 'permissions', 'aspectNames', ...includeFields].filter(\n            (element, index, array) => index === array.indexOf(element)\n        );\n\n        const params: any = {\n            includeSource: true,\n            include: includeFieldsRequest\n        };\n\n        if (folder) {\n            params.relativePath = folder;\n        }\n\n        if (opts) {\n            if (opts.maxItems) {\n                params.maxItems = opts.maxItems;\n            }\n            if (opts.skipCount) {\n                params.skipCount = opts.skipCount;\n            }\n            if (opts.where) {\n                params.where = opts.where;\n            }\n            if (opts.orderBy) {\n                params.orderBy = opts.orderBy;\n            }\n        }\n\n        return from(this.nodes.listNodeChildren(rootNodeId, params));\n    }\n\n    /**\n     * Gets a node via its node ID.\n     *\n     * @param nodeId ID of the target node\n     * @param includeFields Extra information to include (available options are \"aspectNames\", \"isLink\" and \"association\")\n     * @returns Details of the folder\n     */\n    getNode(nodeId: string, includeFields: string[] = []): Observable<Node> {\n        const includeFieldsRequest = ['path', 'properties', 'allowableOperations', 'permissions', 'definition', ...includeFields].filter(\n            (element, index, array) => index === array.indexOf(element)\n        );\n\n        const opts: any = {\n            includeSource: true,\n            include: includeFieldsRequest\n        };\n\n        return this.nodesApiService.getNode(nodeId, opts);\n    }\n\n    /**\n     * Gets a folder node via its node ID.\n     *\n     * @param nodeId ID of the folder node\n     * @param includeFields Extra information to include (available options are \"aspectNames\", \"isLink\" and \"association\")\n     * @returns Details of the folder\n     */\n    getFolderNode(nodeId: string, includeFields: string[] = []): Observable<NodeEntry> {\n        const includeFieldsRequest = ['path', 'properties', 'allowableOperations', 'permissions', 'aspectNames', ...includeFields].filter(\n            (element, index, array) => index === array.indexOf(element)\n        );\n\n        const opts: any = {\n            includeSource: true,\n            include: includeFieldsRequest\n        };\n\n        return from(this.nodes.getNode(nodeId, opts));\n    }\n\n    isCustomSourceService(nodeId: string): boolean {\n        return this.customResourcesService.isCustomSource(nodeId);\n    }\n\n    /**\n     * Load a folder by Node Id.\n     *\n     * @param nodeId ID of the folder node\n     * @param pagination pagination model\n     * @param includeFields List of data field names to include in the results\n     * @param where  Optionally filter the list\n     * @param orderBy order by node property\n     * @returns Details of the folder\n     */\n    loadFolderByNodeId(\n        nodeId: string,\n        pagination: PaginationModel,\n        includeFields: string[],\n        where?: string,\n        orderBy?: string[]\n    ): Observable<DocumentLoaderNode> {\n        if (this.customResourcesService.isCustomSource(nodeId)) {\n            return this.customResourcesService\n                .loadFolderByNodeId(nodeId, pagination, includeFields, where)\n                .pipe(map((result: any) => new DocumentLoaderNode(null, result)));\n        } else {\n            return this.retrieveDocumentNode(nodeId, pagination, includeFields, where, orderBy);\n        }\n    }\n\n    private retrieveDocumentNode(\n        nodeId: string,\n        pagination: PaginationModel,\n        includeFields: string[],\n        where?: string,\n        orderBy?: string[]\n    ): Observable<DocumentLoaderNode> {\n        return forkJoin([\n            this.getFolderNode(nodeId, includeFields),\n            this.getFolder(\n                null,\n                {\n                    maxItems: pagination.maxItems,\n                    skipCount: pagination.skipCount,\n                    orderBy,\n                    rootFolderId: nodeId,\n                    where\n                },\n                includeFields\n            )\n        ]).pipe(map((results) => new DocumentLoaderNode(results[0], results[1])));\n    }\n}\n"]}

package/esm2022/lib/document-list/services/folder-actions.service.mjs

@@ -0,0 +1,137 @@
+/*!
+ * @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 { TranslationService } from '@alfresco/adf-core';
+import { ContentService } from '../../common/services/content.service';
+import { Injectable } from '@angular/core';
+import { Subject, throwError, of } from 'rxjs';
+import { PermissionModel } from '../models/permissions.model';
+import { DocumentListService } from './document-list.service';
+import { NodeActionsService } from './node-actions.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./node-actions.service";
+import * as i2 from "./document-list.service";
+import * as i3 from "../../common/services/content.service";
+import * as i4 from "@alfresco/adf-core";
+export class FolderActionsService {
+    constructor(nodeActionsService, documentListService, contentService, translation) {
+        this.nodeActionsService = nodeActionsService;
+        this.documentListService = documentListService;
+        this.contentService = contentService;
+        this.translation = translation;
+        this.permissionEvent = new Subject();
+        this.error = new Subject();
+        this.success = new Subject();
+        this.handlers = {};
+        this.setupActionHandlers();
+    }
+    /**
+     * Gets the handler function for an action.
+     *
+     * @param key Identifier for the action
+     * @returns The handler function
+     */
+    getHandler(key) {
+        if (key) {
+            const lKey = key.toLowerCase();
+            return this.handlers[lKey] || null;
+        }
+        return null;
+    }
+    /**
+     * Sets a new handler function for an action.
+     *
+     * @param key Identifier for the action
+     * @param handler The new handler function
+     * @returns True if the key was a valid action identifier, false otherwise
+     */
+    setHandler(key, handler) {
+        if (key) {
+            const lKey = key.toLowerCase();
+            this.handlers[lKey] = handler;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if an action is available for a particular item.
+     *
+     * @param nodeEntry Item to check
+     * @returns True if the action is available, false otherwise
+     */
+    canExecuteAction(nodeEntry) {
+        return this.documentListService && nodeEntry && nodeEntry.entry.isFolder === true;
+    }
+    setupActionHandlers() {
+        this.handlers['copy'] = this.copyNode.bind(this);
+        this.handlers['move'] = this.moveNode.bind(this);
+        this.handlers['delete'] = this.deleteNode.bind(this);
+        this.handlers['download'] = this.downloadNode.bind(this);
+    }
+    downloadNode(nodeEntry) {
+        this.nodeActionsService.downloadNode(nodeEntry);
+    }
+    copyNode(nodeEntry, target, permission) {
+        const actionObservable = this.nodeActionsService.copyFolder(nodeEntry.entry, permission);
+        this.prepareHandlers(actionObservable, target);
+        return actionObservable;
+    }
+    moveNode(nodeEntry, target, permission) {
+        const actionObservable = this.nodeActionsService.moveFolder(nodeEntry.entry, permission);
+        this.prepareHandlers(actionObservable, target);
+        return actionObservable;
+    }
+    prepareHandlers(actionObservable, target) {
+        actionObservable.subscribe((fileOperationMessage) => {
+            if (target && typeof target.reload === 'function') {
+                target.reload();
+            }
+            this.success.next(fileOperationMessage);
+        }, this.error.next.bind(this.error));
+    }
+    deleteNode(node, target, permission) {
+        if (this.canExecuteAction(node)) {
+            if (this.contentService.hasAllowableOperations(node.entry, permission)) {
+                const handlerObservable = this.documentListService.deleteNode(node.entry.id);
+                handlerObservable.subscribe(() => {
+                    if (target && typeof target.reload === 'function') {
+                        target.reload();
+                    }
+                    const message = this.translation.instant('CORE.DELETE_NODE.SINGULAR', { name: node.entry.name });
+                    this.success.next(message);
+                }, () => {
+                    const message = this.translation.instant('CORE.DELETE_NODE.ERROR_SINGULAR', { name: node.entry.name });
+                    this.error.next(message);
+                });
+                return handlerObservable;
+            }
+            else {
+                this.permissionEvent.next(new PermissionModel({ type: 'folder', action: 'delete', permission }));
+                return throwError(new Error('No permission to delete'));
+            }
+        }
+        return of();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FolderActionsService, deps: [{ token: i1.NodeActionsService }, { token: i2.DocumentListService }, { token: i3.ContentService }, { token: i4.TranslationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FolderActionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FolderActionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.NodeActionsService }, { type: i2.DocumentListService }, { type: i3.ContentService }, { type: i4.TranslationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"folder-actions.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/services/folder-actions.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 { TranslationService } from '@alfresco/adf-core';\nimport { ContentService } from '../../common/services/content.service';\nimport { Injectable } from '@angular/core';\nimport { NodeEntry } from '@alfresco/js-api';\nimport { Observable, Subject, throwError, of } from 'rxjs';\nimport { ContentActionHandler } from '../models/content-action.model';\nimport { PermissionModel } from '../models/permissions.model';\nimport { DocumentListService } from './document-list.service';\nimport { NodeActionsService } from './node-actions.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FolderActionsService {\n    permissionEvent = new Subject<PermissionModel>();\n    error = new Subject<Error>();\n    success = new Subject<string>();\n\n    private handlers: { [id: string]: ContentActionHandler } = {};\n\n    constructor(\n        private nodeActionsService: NodeActionsService,\n        private documentListService: DocumentListService,\n        private contentService: ContentService,\n        private translation: TranslationService\n    ) {\n        this.setupActionHandlers();\n    }\n\n    /**\n     * Gets the handler function for an action.\n     *\n     * @param key Identifier for the action\n     * @returns The handler function\n     */\n    getHandler(key: string): ContentActionHandler {\n        if (key) {\n            const lKey = key.toLowerCase();\n            return this.handlers[lKey] || null;\n        }\n        return null;\n    }\n\n    /**\n     * Sets a new handler function for an action.\n     *\n     * @param key Identifier for the action\n     * @param handler The new handler function\n     * @returns True if the key was a valid action identifier, false otherwise\n     */\n    setHandler(key: string, handler: ContentActionHandler): boolean {\n        if (key) {\n            const lKey = key.toLowerCase();\n            this.handlers[lKey] = handler;\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Checks if an action is available for a particular item.\n     *\n     * @param nodeEntry Item to check\n     * @returns True if the action is available, false otherwise\n     */\n    canExecuteAction(nodeEntry: NodeEntry): boolean {\n        return this.documentListService && nodeEntry && nodeEntry.entry.isFolder === true;\n    }\n\n    private setupActionHandlers() {\n        this.handlers['copy'] = this.copyNode.bind(this);\n        this.handlers['move'] = this.moveNode.bind(this);\n        this.handlers['delete'] = this.deleteNode.bind(this);\n        this.handlers['download'] = this.downloadNode.bind(this);\n    }\n\n    private downloadNode(nodeEntry: NodeEntry) {\n        this.nodeActionsService.downloadNode(nodeEntry);\n    }\n\n    private copyNode(nodeEntry: NodeEntry, target?: any, permission?: string) {\n        const actionObservable = this.nodeActionsService.copyFolder(nodeEntry.entry, permission);\n        this.prepareHandlers(actionObservable, target);\n        return actionObservable;\n    }\n\n    private moveNode(nodeEntry: NodeEntry, target?: any, permission?: string) {\n        const actionObservable = this.nodeActionsService.moveFolder(nodeEntry.entry, permission);\n        this.prepareHandlers(actionObservable, target);\n        return actionObservable;\n    }\n\n    private prepareHandlers(actionObservable: Observable<any>, target?: any): void {\n        actionObservable.subscribe((fileOperationMessage) => {\n            if (target && typeof target.reload === 'function') {\n                target.reload();\n            }\n            this.success.next(fileOperationMessage);\n        }, this.error.next.bind(this.error));\n    }\n\n    private deleteNode(node: NodeEntry, target?: any, permission?: string): Observable<any> {\n        if (this.canExecuteAction(node)) {\n            if (this.contentService.hasAllowableOperations(node.entry, permission)) {\n                const handlerObservable = this.documentListService.deleteNode(node.entry.id);\n                handlerObservable.subscribe(\n                    () => {\n                        if (target && typeof target.reload === 'function') {\n                            target.reload();\n                        }\n\n                        const message = this.translation.instant('CORE.DELETE_NODE.SINGULAR', { name: node.entry.name });\n                        this.success.next(message);\n                    },\n                    () => {\n                        const message = this.translation.instant('CORE.DELETE_NODE.ERROR_SINGULAR', { name: node.entry.name });\n                        this.error.next(message);\n                    }\n                );\n\n                return handlerObservable;\n            } else {\n                this.permissionEvent.next(new PermissionModel({ type: 'folder', action: 'delete', permission }));\n                return throwError(new Error('No permission to delete'));\n            }\n        }\n\n        return of();\n    }\n}\n"]}

package/esm2022/lib/document-list/services/lock.service.mjs

@@ -0,0 +1,72 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { AuthenticationService } from '@alfresco/adf-core';
+import { isAfter } from 'date-fns';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class LockService {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    isLocked(node) {
+        let isLocked = false;
+        if (this.hasLockConfigured(node)) {
+            if (this.isReadOnlyLock(node)) {
+                isLocked = !this.isLockExpired(node);
+            }
+            else if (this.isLockOwnerAllowed(node)) {
+                isLocked = this.authService.getEcmUsername() !== node.properties['cm:lockOwner'].id;
+                if (this.isLockExpired(node)) {
+                    isLocked = false;
+                }
+            }
+        }
+        return isLocked;
+    }
+    hasLockConfigured(node) {
+        return node.isFile && node.isLocked && node.properties['cm:lockType'];
+    }
+    isReadOnlyLock(node) {
+        return node.properties['cm:lockType'] === 'READ_ONLY_LOCK' && node.properties['cm:lockLifetime'] === 'PERSISTENT';
+    }
+    isLockOwnerAllowed(node) {
+        return node.properties['cm:lockType'] === 'WRITE_LOCK' && node.properties['cm:lockLifetime'] === 'PERSISTENT';
+    }
+    getLockExpiryTime(node) {
+        if (node.properties['cm:expiryDate']) {
+            return new Date(node.properties['cm:expiryDate']);
+        }
+        return undefined;
+    }
+    isLockExpired(node) {
+        const expiryLockTime = this.getLockExpiryTime(node);
+        if (expiryLockTime) {
+            return isAfter(new Date(), expiryLockTime);
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LockService, deps: [{ token: i1.AuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LockService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LockService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthenticationService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jay5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvbnRlbnQtc2VydmljZXMvc3JjL2xpYi9kb2N1bWVudC1saXN0L3NlcnZpY2VzL2xvY2suc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzNELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxVQUFVLENBQUM7OztBQUtuQyxNQUFNLE9BQU8sV0FBVztJQUNwQixZQUFvQixXQUFrQztRQUFsQyxnQkFBVyxHQUFYLFdBQVcsQ0FBdUI7SUFBRyxDQUFDO0lBRTFELFFBQVEsQ0FBQyxJQUFVO1FBQ2YsSUFBSSxRQUFRLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLElBQUksSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDL0IsSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7Z0JBQzVCLFFBQVEsR0FBRyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDekMsQ0FBQztpQkFBTSxJQUFJLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO2dCQUN2QyxRQUFRLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxjQUFjLEVBQUUsS0FBSyxJQUFJLENBQUMsVUFBVSxDQUFDLGNBQWMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDcEYsSUFBSSxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7b0JBQzNCLFFBQVEsR0FBRyxLQUFLLENBQUM7Z0JBQ3JCLENBQUM7WUFDTCxDQUFDO1FBQ0wsQ0FBQztRQUNELE9BQU8sUUFBUSxDQUFDO0lBQ3BCLENBQUM7SUFFTyxpQkFBaUIsQ0FBQyxJQUFVO1FBQ2hDLE9BQU8sSUFBSSxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsUUFBUSxJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDMUUsQ0FBQztJQUVPLGNBQWMsQ0FBQyxJQUFVO1FBQzdCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUMsS0FBSyxnQkFBZ0IsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLGlCQUFpQixDQUFDLEtBQUssWUFBWSxDQUFDO0lBQ3RILENBQUM7SUFFTyxrQkFBa0IsQ0FBQyxJQUFVO1FBQ2pDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUMsS0FBSyxZQUFZLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLFlBQVksQ0FBQztJQUNsSCxDQUFDO0lBRU8saUJBQWlCLENBQUMsSUFBVTtRQUNoQyxJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQztZQUNuQyxPQUFPLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQztRQUN0RCxDQUFDO1FBQ0QsT0FBTyxTQUFTLENBQUM7SUFDckIsQ0FBQztJQUVPLGFBQWEsQ0FBQyxJQUFVO1FBQzVCLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNwRCxJQUFJLGNBQWMsRUFBRSxDQUFDO1lBQ2pCLE9BQU8sT0FBTyxDQUFDLElBQUksSUFBSSxFQUFFLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFDL0MsQ0FBQztRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7K0dBM0NRLFdBQVc7bUhBQVgsV0FBVyxjQUZSLE1BQU07OzRGQUVULFdBQVc7a0JBSHZCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOb2RlIH0gZnJvbSAnQGFsZnJlc2NvL2pzLWFwaSc7XG5pbXBvcnQgeyBBdXRoZW50aWNhdGlvblNlcnZpY2UgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvcmUnO1xuaW1wb3J0IHsgaXNBZnRlciB9IGZyb20gJ2RhdGUtZm5zJztcblxuQEluamVjdGFibGUoe1xuICAgIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBMb2NrU2VydmljZSB7XG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBhdXRoU2VydmljZTogQXV0aGVudGljYXRpb25TZXJ2aWNlKSB7fVxuXG4gICAgaXNMb2NrZWQobm9kZTogTm9kZSk6IGJvb2xlYW4ge1xuICAgICAgICBsZXQgaXNMb2NrZWQgPSBmYWxzZTtcbiAgICAgICAgaWYgKHRoaXMuaGFzTG9ja0NvbmZpZ3VyZWQobm9kZSkpIHtcbiAgICAgICAgICAgIGlmICh0aGlzLmlzUmVhZE9ubHlMb2NrKG5vZGUpKSB7XG4gICAgICAgICAgICAgICAgaXNMb2NrZWQgPSAhdGhpcy5pc0xvY2tFeHBpcmVkKG5vZGUpO1xuICAgICAgICAgICAgfSBlbHNlIGlmICh0aGlzLmlzTG9ja093bmVyQWxsb3dlZChub2RlKSkge1xuICAgICAgICAgICAgICAgIGlzTG9ja2VkID0gdGhpcy5hdXRoU2VydmljZS5nZXRFY21Vc2VybmFtZSgpICE9PSBub2RlLnByb3BlcnRpZXNbJ2NtOmxvY2tPd25lciddLmlkO1xuICAgICAgICAgICAgICAgIGlmICh0aGlzLmlzTG9ja0V4cGlyZWQobm9kZSkpIHtcbiAgICAgICAgICAgICAgICAgICAgaXNMb2NrZWQgPSBmYWxzZTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIGlzTG9ja2VkO1xuICAgIH1cblxuICAgIHByaXZhdGUgaGFzTG9ja0NvbmZpZ3VyZWQobm9kZTogTm9kZSk6IGJvb2xlYW4ge1xuICAgICAgICByZXR1cm4gbm9kZS5pc0ZpbGUgJiYgbm9kZS5pc0xvY2tlZCAmJiBub2RlLnByb3BlcnRpZXNbJ2NtOmxvY2tUeXBlJ107XG4gICAgfVxuXG4gICAgcHJpdmF0ZSBpc1JlYWRPbmx5TG9jayhub2RlOiBOb2RlKTogYm9vbGVhbiB7XG4gICAgICAgIHJldHVybiBub2RlLnByb3BlcnRpZXNbJ2NtOmxvY2tUeXBlJ10gPT09ICdSRUFEX09OTFlfTE9DSycgJiYgbm9kZS5wcm9wZXJ0aWVzWydjbTpsb2NrTGlmZXRpbWUnXSA9PT0gJ1BFUlNJU1RFTlQnO1xuICAgIH1cblxuICAgIHByaXZhdGUgaXNMb2NrT3duZXJBbGxvd2VkKG5vZGU6IE5vZGUpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIG5vZGUucHJvcGVydGllc1snY206bG9ja1R5cGUnXSA9PT0gJ1dSSVRFX0xPQ0snICYmIG5vZGUucHJvcGVydGllc1snY206bG9ja0xpZmV0aW1lJ10gPT09ICdQRVJTSVNURU5UJztcbiAgICB9XG5cbiAgICBwcml2YXRlIGdldExvY2tFeHBpcnlUaW1lKG5vZGU6IE5vZGUpOiBEYXRlIHwgdW5kZWZpbmVkIHtcbiAgICAgICAgaWYgKG5vZGUucHJvcGVydGllc1snY206ZXhwaXJ5RGF0ZSddKSB7XG4gICAgICAgICAgICByZXR1cm4gbmV3IERhdGUobm9kZS5wcm9wZXJ0aWVzWydjbTpleHBpcnlEYXRlJ10pO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuXG4gICAgcHJpdmF0ZSBpc0xvY2tFeHBpcmVkKG5vZGU6IE5vZGUpOiBib29sZWFuIHtcbiAgICAgICAgY29uc3QgZXhwaXJ5TG9ja1RpbWUgPSB0aGlzLmdldExvY2tFeHBpcnlUaW1lKG5vZGUpO1xuICAgICAgICBpZiAoZXhwaXJ5TG9ja1RpbWUpIHtcbiAgICAgICAgICAgIHJldHVybiBpc0FmdGVyKG5ldyBEYXRlKCksIGV4cGlyeUxvY2tUaW1lKTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxufVxuIl19

package/esm2022/lib/document-list/services/node-actions.service.mjs

@@ -0,0 +1,122 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable, Output, EventEmitter } from '@angular/core';
+import { Subject } from 'rxjs';
+import { DownloadService } from '@alfresco/adf-core';
+import { MatDialog } from '@angular/material/dialog';
+import { ContentService } from '../../common/services/content.service';
+import { NodeDownloadDirective } from '../../directives/node-download.directive';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { DocumentListService } from './document-list.service';
+import { ContentNodeDialogService } from '../../content-node-selector/content-node-dialog.service';
+import { NodeAction } from '../models/node-action.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../content-node-selector/content-node-dialog.service";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../../common/services/content.service";
+import * as i4 from "./document-list.service";
+import * as i5 from "../../services/alfresco-api.service";
+import * as i6 from "@alfresco/adf-core";
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class NodeActionsService {
+    constructor(contentDialogService, dialogRef, content, documentListService, apiService, dialog, downloadService) {
+        this.contentDialogService = contentDialogService;
+        this.dialogRef = dialogRef;
+        this.content = content;
+        this.documentListService = documentListService;
+        this.apiService = apiService;
+        this.dialog = dialog;
+        this.downloadService = downloadService;
+        this.error = new EventEmitter();
+    }
+    downloadNode(node) {
+        new NodeDownloadDirective(this.apiService, this.downloadService, this.dialog).downloadNode(node);
+    }
+    /**
+     * Copy content node
+     *
+     * @param contentEntry node to copy
+     * @param permission permission which is needed to apply the action
+     * @returns operation result
+     */
+    copyContent(contentEntry, permission) {
+        return this.doFileOperation(NodeAction.COPY, 'content', contentEntry, permission);
+    }
+    /**
+     * Copy folder node
+     *
+     * @param contentEntry node to copy
+     * @param permission permission which is needed to apply the action
+     * @returns operation result
+     */
+    copyFolder(contentEntry, permission) {
+        return this.doFileOperation(NodeAction.COPY, 'folder', contentEntry, permission);
+    }
+    /**
+     * Move content node
+     *
+     * @param contentEntry node to move
+     * @param permission permission which is needed to apply the action
+     * @returns operation result
+     */
+    moveContent(contentEntry, permission) {
+        return this.doFileOperation(NodeAction.MOVE, 'content', contentEntry, permission);
+    }
+    /**
+     * Move folder node
+     *
+     * @param contentEntry node to move
+     * @param permission permission which is needed to apply the action
+     * @returns operation result
+     */
+    moveFolder(contentEntry, permission) {
+        return this.doFileOperation(NodeAction.MOVE, 'folder', contentEntry, permission);
+    }
+    /**
+     * General method for performing the given operation (copy|move)
+     *
+     * @param action the action to perform (copy|move)
+     * @param type type of the content (content|folder)
+     * @param contentEntry the contentEntry which has to have the action performed on
+     * @param permission permission which is needed to apply the action
+     * @returns operation result
+     */
+    doFileOperation(action, type, contentEntry, permission) {
+        const observable = new Subject();
+        this.contentDialogService.openCopyMoveDialog(action, contentEntry, permission).subscribe((selections) => {
+            const selection = selections[0];
+            this.documentListService[`${action.toLowerCase()}Node`]
+                .call(this.documentListService, contentEntry.id, selection.id)
+                .subscribe(observable.next.bind(observable, `OPERATION.SUCCESS.${type.toUpperCase()}.${action}`), observable.error.bind(observable));
+        }, (error) => {
+            observable.error(error);
+            return observable;
+        });
+        return observable;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeActionsService, deps: [{ token: i1.ContentNodeDialogService }, { token: i2.MatDialog }, { token: i3.ContentService }, { token: i4.DocumentListService }, { token: i5.AlfrescoApiService }, { token: i2.MatDialog }, { token: i6.DownloadService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeActionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodeActionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ContentNodeDialogService }, { type: i2.MatDialog }, { type: i3.ContentService }, { type: i4.DocumentListService }, { type: i5.AlfrescoApiService }, { type: i2.MatDialog }, { type: i6.DownloadService }], propDecorators: { error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-actions.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/services/node-actions.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable, Output, EventEmitter } from '@angular/core';\nimport { Node, NodeEntry } from '@alfresco/js-api';\nimport { Subject } from 'rxjs';\nimport { DownloadService } from '@alfresco/adf-core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { ContentService } from '../../common/services/content.service';\nimport { NodeDownloadDirective } from '../../directives/node-download.directive';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\nimport { DocumentListService } from './document-list.service';\nimport { ContentNodeDialogService } from '../../content-node-selector/content-node-dialog.service';\nimport { NodeAction } from '../models/node-action.enum';\n\n@Injectable({\n    providedIn: 'root'\n})\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport class NodeActionsService {\n    @Output()\n    error = new EventEmitter<any>();\n\n    constructor(\n        private contentDialogService: ContentNodeDialogService,\n        public dialogRef: MatDialog,\n        public content: ContentService,\n        private documentListService?: DocumentListService,\n        private apiService?: AlfrescoApiService,\n        private dialog?: MatDialog,\n        private downloadService?: DownloadService\n    ) {}\n\n    downloadNode(node: NodeEntry) {\n        new NodeDownloadDirective(this.apiService, this.downloadService, this.dialog).downloadNode(node);\n    }\n\n    /**\n     * Copy content node\n     *\n     * @param contentEntry node to copy\n     * @param permission permission which is needed to apply the action\n     * @returns operation result\n     */\n    copyContent(contentEntry: Node, permission?: string): Subject<string> {\n        return this.doFileOperation(NodeAction.COPY, 'content', contentEntry, permission);\n    }\n\n    /**\n     * Copy folder node\n     *\n     * @param contentEntry node to copy\n     * @param permission permission which is needed to apply the action\n     * @returns operation result\n     */\n    copyFolder(contentEntry: Node, permission?: string): Subject<string> {\n        return this.doFileOperation(NodeAction.COPY, 'folder', contentEntry, permission);\n    }\n\n    /**\n     * Move content node\n     *\n     * @param contentEntry node to move\n     * @param permission permission which is needed to apply the action\n     * @returns operation result\n     */\n    moveContent(contentEntry: Node, permission?: string): Subject<string> {\n        return this.doFileOperation(NodeAction.MOVE, 'content', contentEntry, permission);\n    }\n\n    /**\n     * Move folder node\n     *\n     * @param contentEntry node to move\n     * @param permission permission which is needed to apply the action\n     * @returns operation result\n     */\n    moveFolder(contentEntry: Node, permission?: string): Subject<string> {\n        return this.doFileOperation(NodeAction.MOVE, 'folder', contentEntry, permission);\n    }\n\n    /**\n     * General method for performing the given operation (copy|move)\n     *\n     * @param action the action to perform (copy|move)\n     * @param type type of the content (content|folder)\n     * @param contentEntry the contentEntry which has to have the action performed on\n     * @param permission permission which is needed to apply the action\n     * @returns operation result\n     */\n    private doFileOperation(\n        action: NodeAction.COPY | NodeAction.MOVE,\n        type: 'content' | 'folder',\n        contentEntry: Node,\n        permission?: string\n    ): Subject<string> {\n        const observable = new Subject<string>();\n\n        this.contentDialogService.openCopyMoveDialog(action, contentEntry, permission).subscribe(\n            (selections: Node[]) => {\n                const selection = selections[0];\n                this.documentListService[`${action.toLowerCase()}Node`]\n                    .call(this.documentListService, contentEntry.id, selection.id)\n                    .subscribe(\n                        observable.next.bind(observable, `OPERATION.SUCCESS.${type.toUpperCase()}.${action}`),\n                        observable.error.bind(observable)\n                    );\n            },\n            (error) => {\n                observable.error(error);\n                return observable;\n            }\n        );\n        return observable;\n    }\n}\n"]}

package/esm2022/lib/group/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL2dyb3VwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

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

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './services/group.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvZ3JvdXAvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2dyb3VwLnNlcnZpY2UnO1xuIl19