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

package/esm2022/lib/common/services/card-view-content-update.service.mjs

@@ -0,0 +1,55 @@
+/*!
+ * @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 { CardViewUpdateService } from '@alfresco/adf-core';
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class CardViewContentUpdateService {
+    constructor(cardViewUpdateService) {
+        this.cardViewUpdateService = cardViewUpdateService;
+        this.itemUpdated$ = new Subject();
+        this.updatedAspect$ = new Subject();
+        this.linkVariables();
+    }
+    update(property, newValue) {
+        this.cardViewUpdateService.update(property, newValue);
+    }
+    updateElement(notification) {
+        this.cardViewUpdateService.updateElement(notification);
+    }
+    updateNodeAspect(node) {
+        this.updatedAspect$.next(node);
+    }
+    linkVariables() {
+        this.linkItemUpdated();
+    }
+    linkItemUpdated() {
+        this.cardViewUpdateService.itemUpdated$.subscribe((res) => {
+            this.itemUpdated$.next(res);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardViewContentUpdateService, deps: [{ token: i1.CardViewUpdateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardViewContentUpdateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardViewContentUpdateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CardViewUpdateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/services/content.service.mjs

@@ -0,0 +1,180 @@
+/*!
+ * @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 { ContentApi } from '@alfresco/js-api';
+import { Subject } from 'rxjs';
+import { AuthenticationService, ThumbnailService } from '@alfresco/adf-core';
+import { PermissionsEnum } from '../models/permissions.enum';
+import { AllowableOperationsEnum } from '../models/allowable-operations.enum';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../services/alfresco-api.service";
+export class ContentService {
+    get contentApi() {
+        this._contentApi = this._contentApi ?? new ContentApi(this.apiService.getInstance());
+        return this._contentApi;
+    }
+    constructor(authService, apiService, thumbnailService) {
+        this.authService = authService;
+        this.apiService = apiService;
+        this.thumbnailService = thumbnailService;
+        this.folderCreated = new Subject();
+        this.folderCreate = new Subject();
+        this.folderEdit = new Subject();
+    }
+    /**
+     * Gets a content URL for the given node.
+     *
+     * @param node Node or Node ID to get URL for.
+     * @param attachment Toggles whether to retrieve content as an attachment for download
+     * @param ticket Custom ticket to use for authentication
+     * @returns URL string or `null`
+     */
+    getContentUrl(node, attachment, ticket) {
+        if (node) {
+            let nodeId;
+            if (typeof node === 'string') {
+                nodeId = node;
+            }
+            else if (node.entry) {
+                nodeId = node.entry.id;
+            }
+            return this.contentApi.getContentUrl(nodeId, attachment, ticket);
+        }
+        return null;
+    }
+    getDocumentThumbnailUrl(nodeId, attachment, ticket) {
+        return this.contentApi.getDocumentThumbnailUrl(nodeId, attachment, ticket);
+    }
+    /**
+     * Checks if the user has permission on that node
+     *
+     * @param node Node to check permissions
+     * @param permission Required permission type
+     * @param userId Optional current user id will be taken by default
+     * @returns True if the user has the required permissions, false otherwise
+     */
+    hasPermissions(node, permission, userId) {
+        let hasPermissions = false;
+        userId = userId ?? this.authService.getEcmUsername();
+        const permissions = [...(node.permissions?.locallySet || []), ...(node.permissions?.inherited || [])].filter((currentPermission) => currentPermission.authorityId === userId);
+        if (permissions.length) {
+            if (permission?.startsWith('!')) {
+                hasPermissions = !permissions.find((currentPermission) => currentPermission.name === permission.replace('!', ''));
+            }
+            else {
+                hasPermissions = !!permissions.find((currentPermission) => currentPermission.name === permission);
+            }
+        }
+        else {
+            if (permission === PermissionsEnum.CONSUMER) {
+                hasPermissions = true;
+            }
+            else if (permission === PermissionsEnum.NOT_CONSUMER) {
+                hasPermissions = false;
+            }
+            else if (permission?.startsWith('!')) {
+                hasPermissions = true;
+            }
+        }
+        return hasPermissions;
+    }
+    /**
+     * Checks if the user has permissions on that node
+     *
+     * @param node Node to check allowableOperations
+     * @param allowableOperation Create, delete, update, updatePermissions, !create, !delete, !update, !updatePermissions
+     * @returns True if the user has the required permissions, false otherwise
+     */
+    hasAllowableOperations(node, allowableOperation) {
+        let hasAllowableOperations = false;
+        if (node?.allowableOperations) {
+            if (allowableOperation?.startsWith('!')) {
+                hasAllowableOperations = !node.allowableOperations.find((currentOperation) => currentOperation === allowableOperation.replace('!', ''));
+            }
+            else {
+                hasAllowableOperations = !!node.allowableOperations.find((currentOperation) => currentOperation === allowableOperation);
+            }
+        }
+        else {
+            if (allowableOperation?.startsWith('!')) {
+                hasAllowableOperations = true;
+            }
+        }
+        if (allowableOperation === AllowableOperationsEnum.COPY) {
+            hasAllowableOperations = true;
+        }
+        if (allowableOperation === AllowableOperationsEnum.LOCK) {
+            hasAllowableOperations = node.isFile;
+            if (node.isLocked && node.allowableOperations) {
+                hasAllowableOperations = !!~node.allowableOperations.indexOf('updatePermissions');
+            }
+        }
+        return hasAllowableOperations;
+    }
+    getNodeIcon(node) {
+        if (node?.isFolder) {
+            return this.getFolderIcon(node);
+        }
+        if (node?.isFile) {
+            return this.thumbnailService.getMimeTypeIcon(node?.content?.mimeType);
+        }
+        return this.thumbnailService.getDefaultMimeTypeIcon();
+    }
+    getFolderIcon(node) {
+        if (this.isSmartFolder(node)) {
+            return this.thumbnailService.getMimeTypeIcon('smartFolder');
+        }
+        else if (this.isRuleFolder(node)) {
+            return this.thumbnailService.getMimeTypeIcon('ruleFolder');
+        }
+        else if (this.isLinkFolder(node)) {
+            return this.thumbnailService.getMimeTypeIcon('linkFolder');
+        }
+        else {
+            return this.thumbnailService.getMimeTypeIcon('folder');
+        }
+    }
+    isSmartFolder(node) {
+        if (node) {
+            return this.hasAspect(node, 'smf:customConfigSmartFolder') || this.hasAspect(node, 'smf:systemConfigSmartFolder');
+        }
+        return false;
+    }
+    isRuleFolder(node) {
+        if (node) {
+            return this.hasAspect(node, 'rule:rules');
+        }
+        return false;
+    }
+    isLinkFolder(node) {
+        return node?.nodeType === 'app:folderlink';
+    }
+    hasAspect(node, aspectName) {
+        return node?.aspectNames?.includes(aspectName);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentService, deps: [{ token: i1.AuthenticationService }, { token: i2.AlfrescoApiService }, { token: i1.ThumbnailService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthenticationService }, { type: i2.AlfrescoApiService }, { type: i1.ThumbnailService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/content.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAmB,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;;;;AAYzE,MAAM,OAAO,cAAc;IAMvB,IAAI,UAAU;QACV,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;QACrF,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,YAAmB,WAAkC,EAAS,UAA8B,EAAU,gBAAmC;QAAtH,gBAAW,GAAX,WAAW,CAAuB;QAAS,eAAU,GAAV,UAAU,CAAoB;QAAU,qBAAgB,GAAhB,gBAAgB,CAAmB;QAVzI,kBAAa,GAAG,IAAI,OAAO,EAAsB,CAAC;QAClD,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QACnC,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;IAQ2G,CAAC;IAE7I;;;;;;;OAOG;IACH,aAAa,CAAC,IAAwB,EAAE,UAAoB,EAAE,MAAe;QACzE,IAAI,IAAI,EAAE,CAAC;YACP,IAAI,MAAc,CAAC;YAEnB,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,GAAG,IAAI,CAAC;YAClB,CAAC;iBAAM,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACpB,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,CAAC;YAED,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,uBAAuB,CAAC,MAAc,EAAE,UAAoB,EAAE,MAAe;QACzE,OAAO,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAC/E,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,IAAU,EAAE,UAAoC,EAAE,MAAe;QAC5E,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,MAAM,GAAG,MAAM,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;QAErD,MAAM,WAAW,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CACxG,CAAC,iBAAiB,EAAE,EAAE,CAAC,iBAAiB,CAAC,WAAW,KAAK,MAAM,CAClE,CAAC;QACF,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;YACrB,IAAI,UAAU,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC9B,cAAc,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,iBAAiB,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,KAAK,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;YACtH,CAAC;iBAAM,CAAC;gBACJ,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,iBAAiB,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;YACtG,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,IAAI,UAAU,KAAK,eAAe,CAAC,QAAQ,EAAE,CAAC;gBAC1C,cAAc,GAAG,IAAI,CAAC;YAC1B,CAAC;iBAAM,IAAI,UAAU,KAAK,eAAe,CAAC,YAAY,EAAE,CAAC;gBACrD,cAAc,GAAG,KAAK,CAAC;YAC3B,CAAC;iBAAM,IAAI,UAAU,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACrC,cAAc,GAAG,IAAI,CAAC;YAC1B,CAAC;QACL,CAAC;QAED,OAAO,cAAc,CAAC;IAC1B,CAAC;IAED;;;;;;OAMG;IACH,sBAAsB,CAAC,IAAU,EAAE,kBAAoD;QACnF,IAAI,sBAAsB,GAAG,KAAK,CAAC;QAEnC,IAAI,IAAI,EAAE,mBAAmB,EAAE,CAAC;YAC5B,IAAI,kBAAkB,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACtC,sBAAsB,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CACnD,CAAC,gBAAgB,EAAE,EAAE,CAAC,gBAAgB,KAAK,kBAAkB,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CACjF,CAAC;YACN,CAAC;iBAAM,CAAC;gBACJ,sBAAsB,GAAG,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,gBAAgB,EAAE,EAAE,CAAC,gBAAgB,KAAK,kBAAkB,CAAC,CAAC;YAC5H,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,IAAI,kBAAkB,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACtC,sBAAsB,GAAG,IAAI,CAAC;YAClC,CAAC;QACL,CAAC;QAED,IAAI,kBAAkB,KAAK,uBAAuB,CAAC,IAAI,EAAE,CAAC;YACtD,sBAAsB,GAAG,IAAI,CAAC;QAClC,CAAC;QAED,IAAI,kBAAkB,KAAK,uBAAuB,CAAC,IAAI,EAAE,CAAC;YACtD,sBAAsB,GAAG,IAAI,CAAC,MAAM,CAAC;YAErC,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC5C,sBAAsB,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;YACtF,CAAC;QACL,CAAC;QAED,OAAO,sBAAsB,CAAC;IAClC,CAAC;IAED,WAAW,CAAC,IAAU;QAClB,IAAI,IAAI,EAAE,QAAQ,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;QACD,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;YACf,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC1E,CAAC;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC,sBAAsB,EAAE,CAAC;IAC1D,CAAC;IAEO,aAAa,CAAC,IAAU;QAC5B,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;QAChE,CAAC;aAAM,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;QAC/D,CAAC;aAAM,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;QAC/D,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC3D,CAAC;IACL,CAAC;IAED,aAAa,CAAC,IAAU;QACpB,IAAI,IAAI,EAAE,CAAC;YACP,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,6BAA6B,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,6BAA6B,CAAC,CAAC;QACtH,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,YAAY,CAAC,IAAU;QACnB,IAAI,IAAI,EAAE,CAAC;YACP,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,YAAY,CAAC,IAAU;QACnB,OAAO,IAAI,EAAE,QAAQ,KAAK,gBAAgB,CAAC;IAC/C,CAAC;IAEO,SAAS,CAAC,IAAU,EAAE,UAAkB;QAC5C,OAAO,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IACnD,CAAC;+GA5JQ,cAAc;mHAAd,cAAc,cAFX,MAAM;;4FAET,cAAc;kBAH1B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","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 } from '@angular/core';\nimport { ContentApi, Node, NodeEntry } from '@alfresco/js-api';\nimport { Subject } from 'rxjs';\nimport { AuthenticationService, ThumbnailService } from '@alfresco/adf-core';\nimport { PermissionsEnum } from '../models/permissions.enum';\nimport { AllowableOperationsEnum } from '../models/allowable-operations.enum';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\nexport interface FolderCreatedEvent {\n    name: string;\n    relativePath?: string;\n    parentId?: string;\n    node?: NodeEntry;\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ContentService {\n    folderCreated = new Subject<FolderCreatedEvent>();\n    folderCreate = new Subject<Node>();\n    folderEdit = new Subject<Node>();\n\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    constructor(public authService: AuthenticationService, public apiService: AlfrescoApiService, private thumbnailService?: ThumbnailService) {}\n\n    /**\n     * Gets a content URL for the given node.\n     *\n     * @param node Node or Node ID to get URL for.\n     * @param attachment Toggles whether to retrieve content as an attachment for download\n     * @param ticket Custom ticket to use for authentication\n     * @returns URL string or `null`\n     */\n    getContentUrl(node: NodeEntry | string, attachment?: boolean, ticket?: string): string {\n        if (node) {\n            let nodeId: string;\n\n            if (typeof node === 'string') {\n                nodeId = node;\n            } else if (node.entry) {\n                nodeId = node.entry.id;\n            }\n\n            return this.contentApi.getContentUrl(nodeId, attachment, ticket);\n        }\n\n        return null;\n    }\n\n    getDocumentThumbnailUrl(nodeId: string, attachment?: boolean, ticket?: string): string {\n        return this.contentApi.getDocumentThumbnailUrl(nodeId, attachment, ticket);\n    }\n\n    /**\n     * Checks if the user has permission on that node\n     *\n     * @param node Node to check permissions\n     * @param permission Required permission type\n     * @param userId Optional current user id will be taken by default\n     * @returns True if the user has the required permissions, false otherwise\n     */\n    hasPermissions(node: Node, permission: PermissionsEnum | string, userId?: string): boolean {\n        let hasPermissions = false;\n        userId = userId ?? this.authService.getEcmUsername();\n\n        const permissions = [...(node.permissions?.locallySet || []), ...(node.permissions?.inherited || [])].filter(\n            (currentPermission) => currentPermission.authorityId === userId\n        );\n        if (permissions.length) {\n            if (permission?.startsWith('!')) {\n                hasPermissions = !permissions.find((currentPermission) => currentPermission.name === permission.replace('!', ''));\n            } else {\n                hasPermissions = !!permissions.find((currentPermission) => currentPermission.name === permission);\n            }\n        } else {\n            if (permission === PermissionsEnum.CONSUMER) {\n                hasPermissions = true;\n            } else if (permission === PermissionsEnum.NOT_CONSUMER) {\n                hasPermissions = false;\n            } else if (permission?.startsWith('!')) {\n                hasPermissions = true;\n            }\n        }\n\n        return hasPermissions;\n    }\n\n    /**\n     * Checks if the user has permissions on that node\n     *\n     * @param node Node to check allowableOperations\n     * @param allowableOperation Create, delete, update, updatePermissions, !create, !delete, !update, !updatePermissions\n     * @returns True if the user has the required permissions, false otherwise\n     */\n    hasAllowableOperations(node: Node, allowableOperation: AllowableOperationsEnum | string): boolean {\n        let hasAllowableOperations = false;\n\n        if (node?.allowableOperations) {\n            if (allowableOperation?.startsWith('!')) {\n                hasAllowableOperations = !node.allowableOperations.find(\n                    (currentOperation) => currentOperation === allowableOperation.replace('!', '')\n                );\n            } else {\n                hasAllowableOperations = !!node.allowableOperations.find((currentOperation) => currentOperation === allowableOperation);\n            }\n        } else {\n            if (allowableOperation?.startsWith('!')) {\n                hasAllowableOperations = true;\n            }\n        }\n\n        if (allowableOperation === AllowableOperationsEnum.COPY) {\n            hasAllowableOperations = true;\n        }\n\n        if (allowableOperation === AllowableOperationsEnum.LOCK) {\n            hasAllowableOperations = node.isFile;\n\n            if (node.isLocked && node.allowableOperations) {\n                hasAllowableOperations = !!~node.allowableOperations.indexOf('updatePermissions');\n            }\n        }\n\n        return hasAllowableOperations;\n    }\n\n    getNodeIcon(node: Node): string {\n        if (node?.isFolder) {\n            return this.getFolderIcon(node);\n        }\n        if (node?.isFile) {\n            return this.thumbnailService.getMimeTypeIcon(node?.content?.mimeType);\n        }\n        return this.thumbnailService.getDefaultMimeTypeIcon();\n    }\n\n    private getFolderIcon(node: Node): string {\n        if (this.isSmartFolder(node)) {\n            return this.thumbnailService.getMimeTypeIcon('smartFolder');\n        } else if (this.isRuleFolder(node)) {\n            return this.thumbnailService.getMimeTypeIcon('ruleFolder');\n        } else if (this.isLinkFolder(node)) {\n            return this.thumbnailService.getMimeTypeIcon('linkFolder');\n        } else {\n            return this.thumbnailService.getMimeTypeIcon('folder');\n        }\n    }\n\n    isSmartFolder(node: Node): boolean {\n        if (node) {\n            return this.hasAspect(node, 'smf:customConfigSmartFolder') || this.hasAspect(node, 'smf:systemConfigSmartFolder');\n        }\n        return false;\n    }\n\n    isRuleFolder(node: Node): boolean {\n        if (node) {\n            return this.hasAspect(node, 'rule:rules');\n        }\n        return false;\n    }\n\n    isLinkFolder(node: Node): boolean {\n        return node?.nodeType === 'app:folderlink';\n    }\n\n    private hasAspect(node: Node, aspectName: string): boolean {\n        return node?.aspectNames?.includes(aspectName);\n    }\n}\n"]}

package/esm2022/lib/common/services/discovery-api.service.mjs

@@ -0,0 +1,79 @@
+/*!
+ * @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 { from, throwError, Subject } from 'rxjs';
+import { catchError, map, switchMap, filter, take } from 'rxjs/operators';
+import { DiscoveryApi, AboutApi, SystemPropertiesApi } from '@alfresco/js-api';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { BpmProductVersionModel, AuthenticationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../services/alfresco-api.service";
+export class DiscoveryApiService {
+    get discoveryApi() {
+        this._discoveryApi = this._discoveryApi ?? new DiscoveryApi(this.alfrescoApiService.getInstance());
+        return this._discoveryApi;
+    }
+    constructor(authenticationService, alfrescoApiService) {
+        this.authenticationService = authenticationService;
+        this.alfrescoApiService = alfrescoApiService;
+        /**
+         * Gets product information for Content Services.
+         */
+        this.ecmProductInfo$ = new Subject();
+        this.authenticationService.onLogin.subscribe(() => {
+            this.alfrescoApiService.alfrescoApiInitialized
+                .pipe(filter(() => this.authenticationService.isEcmLoggedIn()), take(1), switchMap(() => this.getEcmProductInfo()))
+                .subscribe((info) => this.ecmProductInfo$.next(info));
+        });
+    }
+    /**
+     * Gets product information for Content Services.
+     *
+     * @returns ProductVersionModel containing product details
+     */
+    getEcmProductInfo() {
+        return from(this.discoveryApi.getRepositoryInformation()).pipe(map((res) => res.entry.repository), catchError((err) => throwError(err)));
+    }
+    /**
+     * Gets product information for Process Services.
+     *
+     * @returns ProductVersionModel containing product details
+     */
+    getBpmProductInfo() {
+        const aboutApi = new AboutApi(this.alfrescoApiService.getInstance());
+        return from(aboutApi.getAppVersion()).pipe(map((res) => new BpmProductVersionModel(res)), catchError((err) => throwError(err)));
+    }
+    getBPMSystemProperties() {
+        const systemPropertiesApi = new SystemPropertiesApi(this.alfrescoApiService.getInstance());
+        return from(systemPropertiesApi.getProperties()).pipe(map((res) => {
+            if ('string' === typeof res) {
+                throw new Error('Not valid response');
+            }
+            return res;
+        }), catchError((err) => throwError(err.error)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DiscoveryApiService, deps: [{ token: i1.AuthenticationService }, { token: i2.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DiscoveryApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DiscoveryApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthenticationService }, { type: i2.AlfrescoApiService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/services/favorites-api.service.mjs

@@ -0,0 +1,84 @@
+/*!
+ * @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 { FavoritesApi } from '@alfresco/js-api';
+import { from, of } from 'rxjs';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { UserPreferencesService } from '@alfresco/adf-core';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export class FavoritesApiService {
+    get favoritesApi() {
+        this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.apiService.getInstance());
+        return this._favoritesApi;
+    }
+    static remapEntry({ entry }) {
+        entry.properties = {
+            'cm:title': entry.title,
+            'cm:description': entry.description
+        };
+        return { entry };
+    }
+    constructor(apiService, preferences) {
+        this.apiService = apiService;
+        this.preferences = preferences;
+    }
+    remapFavoritesData(data = {}) {
+        const pagination = data?.list?.pagination || {};
+        const entries = this.remapFavoriteEntries(data?.list?.entries || []);
+        return {
+            list: { entries, pagination }
+        };
+    }
+    remapFavoriteEntries(entries) {
+        return entries
+            .map(({ entry: { target } }) => ({
+            entry: target.file || target.folder
+        }))
+            .filter(({ entry }) => !!entry)
+            .map(FavoritesApiService.remapEntry);
+    }
+    /**
+     * Gets the favorites for a user.
+     *
+     * @param personId ID of the user
+     * @param options Options supported by JS-API
+     * @returns List of favorites
+     */
+    getFavorites(personId, options) {
+        const defaultOptions = {
+            maxItems: this.preferences.paginationSize,
+            skipCount: 0,
+            where: '(EXISTS(target/file) OR EXISTS(target/folder))',
+            include: ['properties', 'allowableOperations']
+        };
+        const queryOptions = Object.assign(defaultOptions, options);
+        const promise = this.favoritesApi.listFavorites(personId, queryOptions).then(this.remapFavoritesData);
+        return from(promise).pipe(catchError((err) => of(err)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FavoritesApiService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FavoritesApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FavoritesApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.UserPreferencesService }] });
+//# sourceMappingURL=data:application/json;base64,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