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

package/esm2022/lib/content-metadata/services/content-metadata.service.mjs

@@ -0,0 +1,99 @@
+/*!
+ * @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 { BasicPropertiesService } from './basic-properties.service';
+import { of, iif, Subject } from 'rxjs';
+import { PropertyGroupTranslatorService } from './property-groups-translator.service';
+import { ContentMetadataConfigFactory } from './config/content-metadata-config.factory';
+import { PropertyDescriptorsService } from './property-descriptors.service';
+import { map, switchMap } from 'rxjs/operators';
+import { ContentTypePropertiesService } from './content-type-property.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./basic-properties.service";
+import * as i2 from "./config/content-metadata-config.factory";
+import * as i3 from "./property-groups-translator.service";
+import * as i4 from "./property-descriptors.service";
+import * as i5 from "./content-type-property.service";
+export class ContentMetadataService {
+    constructor(basicPropertiesService, contentMetadataConfigFactory, propertyGroupTranslatorService, propertyDescriptorsService, contentTypePropertyService) {
+        this.basicPropertiesService = basicPropertiesService;
+        this.contentMetadataConfigFactory = contentMetadataConfigFactory;
+        this.propertyGroupTranslatorService = propertyGroupTranslatorService;
+        this.propertyDescriptorsService = propertyDescriptorsService;
+        this.contentTypePropertyService = contentTypePropertyService;
+        this.error = new Subject();
+    }
+    getBasicProperties(node) {
+        return of(this.basicPropertiesService.getProperties(node));
+    }
+    getContentTypeProperty(node) {
+        return this.contentTypePropertyService.getContentTypeCardItem(node);
+    }
+    openConfirmDialog(changedProperties) {
+        return this.contentTypePropertyService.openContentTypeDialogConfirm(changedProperties.nodeType);
+    }
+    getGroupedProperties(node, preset = 'default') {
+        let groupedProperties = of([]);
+        if (node.aspectNames) {
+            let contentMetadataConfig;
+            if (typeof preset === 'string') {
+                contentMetadataConfig = this.contentMetadataConfigFactory.get(preset);
+            }
+            else {
+                contentMetadataConfig = this.contentMetadataConfigFactory.createConfig(preset);
+            }
+            const groupNames = node.aspectNames.concat(node.nodeType).filter((groupName) => contentMetadataConfig.isGroupAllowed(groupName));
+            if (groupNames.length > 0) {
+                groupedProperties = this.propertyDescriptorsService.load(groupNames).pipe(switchMap((groups) => iif(() => contentMetadataConfig.isIncludeAllEnabled(), of(contentMetadataConfig.appendAllPreset(groups).concat(contentMetadataConfig.reorganiseByConfig(groups))), of(contentMetadataConfig.reorganiseByConfig(groups)))), map((groups) => contentMetadataConfig.filterExcludedPreset(groups)), map((groups) => this.filterEmptyPreset(groups)), map((groups) => this.setTitleToNameIfNotSet(groups)), map((groups) => this.propertyGroupTranslatorService.translateToCardViewGroups(groups, node.properties, node.definition)));
+            }
+        }
+        return groupedProperties;
+    }
+    setTitleToNameIfNotSet(propertyGroups) {
+        const propertyGroupsTitles = [];
+        propertyGroups.map((propertyGroup) => {
+            const title = propertyGroup.title;
+            const name = propertyGroup.name;
+            if (title) {
+                if (propertyGroupsTitles.includes(title)) {
+                    propertyGroup.title = name ? `${title} (${name})` : title;
+                }
+                else {
+                    propertyGroup.title = title;
+                }
+                propertyGroupsTitles.push(title);
+            }
+            else {
+                propertyGroup.title = name;
+                propertyGroupsTitles.push(name);
+            }
+        });
+        return propertyGroups;
+    }
+    filterEmptyPreset(propertyGroups) {
+        return propertyGroups.filter((props) => props.properties.length);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentMetadataService, deps: [{ token: i1.BasicPropertiesService }, { token: i2.ContentMetadataConfigFactory }, { token: i3.PropertyGroupTranslatorService }, { token: i4.PropertyDescriptorsService }, { token: i5.ContentTypePropertiesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentMetadataService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentMetadataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.BasicPropertiesService }, { type: i2.ContentMetadataConfigFactory }, { type: i3.PropertyGroupTranslatorService }, { type: i4.PropertyDescriptorsService }, { type: i5.ContentTypePropertiesService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-metadata.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/content-metadata/services/content-metadata.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 } from '@angular/core';\nimport { Node } from '@alfresco/js-api';\nimport { BasicPropertiesService } from './basic-properties.service';\nimport { Observable, of, iif, Subject } from 'rxjs';\nimport { PropertyGroupTranslatorService } from './property-groups-translator.service';\nimport { CardViewItem } from '@alfresco/adf-core';\nimport { CardViewGroup, OrganisedPropertyGroup, PresetConfig } from '../interfaces/content-metadata.interfaces';\nimport { ContentMetadataConfigFactory } from './config/content-metadata-config.factory';\nimport { PropertyDescriptorsService } from './property-descriptors.service';\nimport { map, switchMap } from 'rxjs/operators';\nimport { ContentTypePropertiesService } from './content-type-property.service';\n@Injectable({\n    providedIn: 'root'\n})\nexport class ContentMetadataService {\n    error = new Subject<{ statusCode: number; message: string }>();\n\n    constructor(\n        private basicPropertiesService: BasicPropertiesService,\n        private contentMetadataConfigFactory: ContentMetadataConfigFactory,\n        private propertyGroupTranslatorService: PropertyGroupTranslatorService,\n        private propertyDescriptorsService: PropertyDescriptorsService,\n        private contentTypePropertyService: ContentTypePropertiesService\n    ) {}\n\n    getBasicProperties(node: Node): Observable<CardViewItem[]> {\n        return of(this.basicPropertiesService.getProperties(node));\n    }\n\n    getContentTypeProperty(node: Node): Observable<CardViewItem[]> {\n        return this.contentTypePropertyService.getContentTypeCardItem(node);\n    }\n\n    openConfirmDialog(changedProperties): Observable<any> {\n        return this.contentTypePropertyService.openContentTypeDialogConfirm(changedProperties.nodeType);\n    }\n\n    getGroupedProperties(node: Node, preset: string | PresetConfig = 'default'): Observable<CardViewGroup[]> {\n        let groupedProperties = of([]);\n\n        if (node.aspectNames) {\n            let contentMetadataConfig;\n            if (typeof preset === 'string') {\n                contentMetadataConfig = this.contentMetadataConfigFactory.get(preset);\n            } else {\n                contentMetadataConfig = this.contentMetadataConfigFactory.createConfig(preset);\n            }\n\n            const groupNames = node.aspectNames.concat(node.nodeType).filter((groupName) => contentMetadataConfig.isGroupAllowed(groupName));\n\n            if (groupNames.length > 0) {\n                groupedProperties = this.propertyDescriptorsService.load(groupNames).pipe(\n                    switchMap((groups) =>\n                        iif(\n                            () => contentMetadataConfig.isIncludeAllEnabled(),\n                            of(contentMetadataConfig.appendAllPreset(groups).concat(contentMetadataConfig.reorganiseByConfig(groups))),\n                            of(contentMetadataConfig.reorganiseByConfig(groups))\n                        )\n                    ),\n                    map((groups) => contentMetadataConfig.filterExcludedPreset(groups)),\n                    map((groups) => this.filterEmptyPreset(groups)),\n                    map((groups) => this.setTitleToNameIfNotSet(groups)),\n                    map((groups) => this.propertyGroupTranslatorService.translateToCardViewGroups(groups, node.properties, node.definition))\n                );\n            }\n        }\n\n        return groupedProperties;\n    }\n\n    setTitleToNameIfNotSet(propertyGroups: OrganisedPropertyGroup[]): OrganisedPropertyGroup[] {\n        const propertyGroupsTitles = [];\n        propertyGroups.map((propertyGroup) => {\n            const title = propertyGroup.title;\n            const name = propertyGroup.name;\n            if (title) {\n                if (propertyGroupsTitles.includes(title)) {\n                    propertyGroup.title = name ? `${title} (${name})` : title;\n                } else {\n                    propertyGroup.title = title;\n                }\n                propertyGroupsTitles.push(title);\n            } else {\n                propertyGroup.title = name;\n                propertyGroupsTitles.push(name);\n            }\n        });\n        return propertyGroups;\n    }\n\n    filterEmptyPreset(propertyGroups: OrganisedPropertyGroup[]): OrganisedPropertyGroup[] {\n        return propertyGroups.filter((props) => props.properties.length);\n    }\n}\n"]}

package/esm2022/lib/content-metadata/services/content-type-property.service.mjs

@@ -0,0 +1,134 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { CardViewSelectItemModel, CardViewTextItemModel } from '@alfresco/adf-core';
+import { of, Subject, zip } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { ContentTypeDialogComponent } from '../../content-type/content-type-dialog.component';
+import { ContentTypeService } from '../../content-type/content-type.service';
+import { PropertyGroupTranslatorService } from './property-groups-translator.service';
+import { VersionCompatibilityService } from '../../version-compatibility/version-compatibility.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../content-type/content-type.service";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../../version-compatibility/version-compatibility.service";
+import * as i4 from "./property-groups-translator.service";
+export class ContentTypePropertiesService {
+    constructor(contentTypeService, dialog, versionCompatibilityService, propertyGroupTranslatorService) {
+        this.contentTypeService = contentTypeService;
+        this.dialog = dialog;
+        this.versionCompatibilityService = versionCompatibilityService;
+        this.propertyGroupTranslatorService = propertyGroupTranslatorService;
+    }
+    getContentTypeCardItem(node) {
+        if (this.versionCompatibilityService.isVersionSupported('7')) {
+            return this.contentTypeService.getContentTypeByPrefix(node.nodeType).pipe(map((contentType) => {
+                const contentTypesOptions$ = this.getContentTypesAsSelectOption(contentType);
+                const contentTypeCard = this.buildContentTypeSelectCardModel(contentType.entry.id, contentTypesOptions$);
+                const filteredProperties = this.getContentTypeSpecificProperties(contentType);
+                const propertiesCard = this.buildCardItemsFromPropertyList(filteredProperties, node.properties);
+                return [contentTypeCard, ...propertiesCard];
+            }));
+        }
+        else {
+            return of([this.buildContentTypeTextCardModel(node.nodeType)]);
+        }
+    }
+    buildCardItemsFromPropertyList(properties, currentProperties) {
+        return properties.map((property) => {
+            const propertyValue = currentProperties ? currentProperties[property.id] : null;
+            return this.buildCardItemFromProperty(property, propertyValue);
+        });
+    }
+    buildCardItemFromProperty(property, propertyValue) {
+        return this.propertyGroupTranslatorService.translateProperty(property, propertyValue, true);
+    }
+    getContentTypeSpecificProperties(contentType) {
+        return contentType.entry.properties.filter((property) => property.id.startsWith(contentType.entry.model.namespacePrefix));
+    }
+    buildContentTypeTextCardModel(currentValue) {
+        const contentTypeCard = new CardViewTextItemModel({
+            label: 'CORE.METADATA.BASIC.CONTENT_TYPE',
+            value: currentValue,
+            key: 'nodeType',
+            editable: false
+        });
+        return contentTypeCard;
+    }
+    buildContentTypeSelectCardModel(currentValue, options$) {
+        const contentTypeCard = new CardViewSelectItemModel({
+            label: 'CORE.METADATA.BASIC.CONTENT_TYPE',
+            value: currentValue,
+            key: 'nodeType',
+            editable: true,
+            options$,
+            displayNoneOption: false
+        });
+        return contentTypeCard;
+    }
+    getContentTypesAsSelectOption(currentType) {
+        const childrenTypes$ = this.contentTypeService.getContentTypeChildren(currentType.entry.id);
+        return zip(childrenTypes$, of(currentType)).pipe(distinctUntilChanged(), map(([contentTypesEntries, currentContentType]) => {
+            const updatedTypes = this.appendCurrentType(currentContentType, contentTypesEntries);
+            return updatedTypes.map((contentType) => ({ key: contentType.entry.id, label: contentType.entry.title ?? contentType.entry.id }));
+        }));
+    }
+    appendCurrentType(currentType, contentTypesEntries) {
+        const resultTypes = [...contentTypesEntries];
+        const currentTypePresent = contentTypesEntries.find((type) => type.entry.id === currentType.entry.id);
+        if (!currentTypePresent) {
+            resultTypes.push(currentType);
+        }
+        return resultTypes;
+    }
+    openContentTypeDialogConfirm(nodeType) {
+        const select = new Subject();
+        select.subscribe({
+            complete: this.close.bind(this)
+        });
+        const data = {
+            title: 'CORE.METADATA.CONTENT_TYPE.DIALOG.TITLE',
+            description: 'CORE.METADATA.CONTENT_TYPE.DIALOG.DESCRIPTION',
+            confirmMessage: 'CORE.METADATA.CONTENT_TYPE.DIALOG.CONFIRM',
+            select,
+            nodeType
+        };
+        this.openDialog(data, 'adf-content-type-dialog', '600px');
+        return select;
+    }
+    close() {
+        this.dialog.closeAll();
+    }
+    openDialog(data, panelClass, width) {
+        this.dialog.open(ContentTypeDialogComponent, {
+            data,
+            panelClass,
+            width,
+            disableClose: true
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentTypePropertiesService, deps: [{ token: i1.ContentTypeService }, { token: i2.MatDialog }, { token: i3.VersionCompatibilityService }, { token: i4.PropertyGroupTranslatorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentTypePropertiesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentTypePropertiesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ContentTypeService }, { type: i2.MatDialog }, { type: i3.VersionCompatibilityService }, { type: i4.PropertyGroupTranslatorService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-type-property.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/content-metadata/services/content-type-property.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 } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { CardViewItem, CardViewSelectItemModel, CardViewSelectItemOption, CardViewTextItemModel } from '@alfresco/adf-core';\nimport { Observable, of, Subject, zip } from 'rxjs';\nimport { distinctUntilChanged, map } from 'rxjs/operators';\nimport { ContentTypeDialogComponent } from '../../content-type/content-type-dialog.component';\nimport { ContentTypeDialogComponentData } from '../../content-type/content-type-metadata.interface';\nimport { ContentTypeService } from '../../content-type/content-type.service';\nimport { Node, Property, TypeEntry } from '@alfresco/js-api';\nimport { PropertyGroupTranslatorService } from './property-groups-translator.service';\nimport { VersionCompatibilityService } from '../../version-compatibility/version-compatibility.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ContentTypePropertiesService {\n    constructor(\n        private contentTypeService: ContentTypeService,\n        private dialog: MatDialog,\n        private versionCompatibilityService: VersionCompatibilityService,\n        private propertyGroupTranslatorService: PropertyGroupTranslatorService\n    ) {}\n\n    getContentTypeCardItem(node: Node): Observable<CardViewItem[]> {\n        if (this.versionCompatibilityService.isVersionSupported('7')) {\n            return this.contentTypeService.getContentTypeByPrefix(node.nodeType).pipe(\n                map((contentType) => {\n                    const contentTypesOptions$ = this.getContentTypesAsSelectOption(contentType);\n                    const contentTypeCard = this.buildContentTypeSelectCardModel(contentType.entry.id, contentTypesOptions$);\n                    const filteredProperties = this.getContentTypeSpecificProperties(contentType);\n                    const propertiesCard = this.buildCardItemsFromPropertyList(filteredProperties, node.properties);\n                    return [contentTypeCard, ...propertiesCard];\n                })\n            );\n        } else {\n            return of([this.buildContentTypeTextCardModel(node.nodeType)]);\n        }\n    }\n\n    buildCardItemsFromPropertyList(properties: Property[], currentProperties: any): CardViewItem[] {\n        return properties.map((property) => {\n            const propertyValue = currentProperties ? currentProperties[property.id] : null;\n            return this.buildCardItemFromProperty(property, propertyValue);\n        });\n    }\n\n    private buildCardItemFromProperty(property: Property, propertyValue: any): CardViewItem {\n        return this.propertyGroupTranslatorService.translateProperty(property, propertyValue, true);\n    }\n\n    private getContentTypeSpecificProperties(contentType: TypeEntry): Property[] {\n        return contentType.entry.properties.filter((property) => property.id.startsWith(contentType.entry.model.namespacePrefix));\n    }\n\n    private buildContentTypeTextCardModel(currentValue: string): CardViewTextItemModel {\n        const contentTypeCard = new CardViewTextItemModel({\n            label: 'CORE.METADATA.BASIC.CONTENT_TYPE',\n            value: currentValue,\n            key: 'nodeType',\n            editable: false\n        });\n\n        return contentTypeCard;\n    }\n\n    private buildContentTypeSelectCardModel(\n        currentValue: string,\n        options$: Observable<CardViewSelectItemOption<string>[]>\n    ): CardViewSelectItemModel<string> {\n        const contentTypeCard = new CardViewSelectItemModel({\n            label: 'CORE.METADATA.BASIC.CONTENT_TYPE',\n            value: currentValue,\n            key: 'nodeType',\n            editable: true,\n            options$,\n            displayNoneOption: false\n        });\n\n        return contentTypeCard;\n    }\n\n    private getContentTypesAsSelectOption(currentType: TypeEntry): Observable<CardViewSelectItemOption<string>[]> {\n        const childrenTypes$ = this.contentTypeService.getContentTypeChildren(currentType.entry.id);\n        return zip(childrenTypes$, of(currentType)).pipe(\n            distinctUntilChanged(),\n            map(([contentTypesEntries, currentContentType]) => {\n                const updatedTypes = this.appendCurrentType(currentContentType, contentTypesEntries);\n                return updatedTypes.map((contentType) => ({ key: contentType.entry.id, label: contentType.entry.title ?? contentType.entry.id }));\n            })\n        );\n    }\n\n    private appendCurrentType(currentType: TypeEntry, contentTypesEntries: TypeEntry[]): TypeEntry[] {\n        const resultTypes = [...contentTypesEntries];\n        const currentTypePresent = contentTypesEntries.find((type) => type.entry.id === currentType.entry.id);\n        if (!currentTypePresent) {\n            resultTypes.push(currentType);\n        }\n        return resultTypes;\n    }\n\n    openContentTypeDialogConfirm(nodeType): Observable<boolean> {\n        const select = new Subject<boolean>();\n        select.subscribe({\n            complete: this.close.bind(this)\n        });\n\n        const data: ContentTypeDialogComponentData = {\n            title: 'CORE.METADATA.CONTENT_TYPE.DIALOG.TITLE',\n            description: 'CORE.METADATA.CONTENT_TYPE.DIALOG.DESCRIPTION',\n            confirmMessage: 'CORE.METADATA.CONTENT_TYPE.DIALOG.CONFIRM',\n            select,\n            nodeType\n        };\n\n        this.openDialog(data, 'adf-content-type-dialog', '600px');\n        return select;\n    }\n\n    close() {\n        this.dialog.closeAll();\n    }\n\n    private openDialog(data: ContentTypeDialogComponentData, panelClass: string, width: string) {\n        this.dialog.open(ContentTypeDialogComponent, {\n            data,\n            panelClass,\n            width,\n            disableClose: true\n        });\n    }\n}\n"]}

package/esm2022/lib/content-metadata/services/property-descriptors.service.mjs

@@ -0,0 +1,52 @@
+/*!
+ * @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 { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { defer, forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ClassesApi } from '@alfresco/js-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+export class PropertyDescriptorsService {
+    get classesApi() {
+        this._classesApi = this._classesApi ?? new ClassesApi(this.alfrescoApiService.getInstance());
+        return this._classesApi;
+    }
+    constructor(alfrescoApiService) {
+        this.alfrescoApiService = alfrescoApiService;
+    }
+    load(groupNames) {
+        const groupFetchStreams = groupNames
+            .map((groupName) => groupName.replace(':', '_'))
+            .map((groupName) => defer(() => this.classesApi.getClass(groupName)));
+        return forkJoin(groupFetchStreams).pipe(map(this.convertToObject));
+    }
+    convertToObject(propertyGroupsArray) {
+        return propertyGroupsArray.reduce((propertyGroups, propertyGroup) => Object.assign({}, propertyGroups, {
+            [propertyGroup.name]: propertyGroup
+        }), {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PropertyDescriptorsService, deps: [{ token: i1.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PropertyDescriptorsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PropertyDescriptorsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/content-metadata/services/property-groups-translator.service.mjs

@@ -0,0 +1,169 @@
+/*!
+ * @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 { inject, Injectable, Injector, runInInjectionContext } from '@angular/core';
+import { AppConfigService, CardViewBoolItemModel, CardViewDateItemModel, CardViewDatetimeItemModel, CardViewFloatItemModel, CardViewIntItemModel, CardViewLongItemModel, CardViewSelectItemModel, CardViewTextItemModel, DecimalNumberPipe, LogService, MultiValuePipe, UserPreferencesService } from '@alfresco/adf-core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+const D_TEXT = 'd:text';
+const D_MLTEXT = 'd:mltext';
+const D_DATE = 'd:date';
+const D_DATETIME = 'd:datetime';
+const D_INT = 'd:int';
+const D_LONG = 'd:long';
+const D_FLOAT = 'd:float';
+const D_DOUBLE = 'd:double';
+const D_BOOLEAN = 'd:boolean';
+export const RECOGNISED_ECM_TYPES = [D_TEXT, D_MLTEXT, D_DATE, D_DATETIME, D_INT, D_LONG, D_FLOAT, D_DOUBLE, D_BOOLEAN];
+export class PropertyGroupTranslatorService {
+    constructor() {
+        this.userPreferenceService = inject(UserPreferencesService);
+        this.appConfig = inject(AppConfigService);
+        this.logService = inject(LogService);
+        this.injector = inject(Injector);
+        this.valueSeparator = this.appConfig.get('content-metadata.multi-value-pipe-separator');
+    }
+    translateToCardViewGroups(propertyGroups, propertyValues, definition) {
+        return propertyGroups.map((propertyGroup) => {
+            const translatedPropertyGroup = Object.assign({}, propertyGroup);
+            translatedPropertyGroup.properties = this.translateArray(propertyGroup.properties, propertyValues, definition);
+            translatedPropertyGroup.editable = translatedPropertyGroup.properties.some((property) => property.editable);
+            return translatedPropertyGroup;
+        });
+    }
+    translateProperty(property, startValue, allowEditing = false) {
+        this.checkECMTypeValidity(property.dataType);
+        const prefix = 'properties.';
+        const propertyDefinition = {
+            label: property.title || property.id,
+            value: startValue ? startValue : property.defaultValue,
+            key: `${prefix}${property.id}`,
+            default: property.defaultValue,
+            editable: property.isProtected ? false : allowEditing,
+            constraints: property?.constraints
+        };
+        return this.transform(propertyDefinition, property.dataType, property.isMultiValued);
+    }
+    translateArray(properties, propertyValues, definition) {
+        return properties.map((property) => this.translate(property, propertyValues, this.getPropertyConstraints(property.name, definition)));
+    }
+    translate(property, propertyValues, constraints) {
+        let propertyValue;
+        if (propertyValues && !this.isEmpty(propertyValues[property.name])) {
+            propertyValue = propertyValues[property.name];
+        }
+        this.checkECMTypeValidity(property.dataType);
+        const prefix = 'properties.';
+        const propertyDefinition = {
+            label: property.title || property.name,
+            value: propertyValue,
+            key: `${prefix}${property.name}`,
+            default: property.defaultValue,
+            editable: property.protected ? false : property.editable !== undefined ? property.editable : true,
+            constraints
+        };
+        return this.transform(propertyDefinition, property.dataType, property.multiValued);
+    }
+    transform(propertyDefinition, dataType, isMultiValued) {
+        let cardViewItemProperty;
+        if (this.isListOfValues(propertyDefinition.constraints)) {
+            const options = propertyDefinition.constraints[0].parameters.allowedValues.map((value) => ({ key: value, label: value }));
+            const properties = Object.assign(propertyDefinition, { options$: of(options) });
+            cardViewItemProperty = new CardViewSelectItemModel(properties);
+        }
+        else {
+            switch (dataType) {
+                case D_MLTEXT:
+                    cardViewItemProperty = new CardViewTextItemModel(Object.assign(propertyDefinition, {
+                        multiline: true
+                    }));
+                    break;
+                case D_INT:
+                    cardViewItemProperty = new CardViewIntItemModel(Object.assign(propertyDefinition, {
+                        multivalued: isMultiValued,
+                        pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]
+                    }));
+                    break;
+                case D_LONG:
+                    cardViewItemProperty = new CardViewLongItemModel(Object.assign(propertyDefinition, {
+                        multivalued: isMultiValued,
+                        pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]
+                    }));
+                    break;
+                case D_FLOAT:
+                case D_DOUBLE:
+                    cardViewItemProperty = new CardViewFloatItemModel(Object.assign(propertyDefinition, {
+                        multivalued: isMultiValued,
+                        pipes: [{ pipe: this.getDecimalNumberPipe() }, { pipe: new MultiValuePipe(), params: [this.valueSeparator] }]
+                    }));
+                    break;
+                case D_DATE:
+                    cardViewItemProperty = new CardViewDateItemModel(Object.assign(propertyDefinition, {
+                        multivalued: isMultiValued,
+                        pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]
+                    }));
+                    break;
+                case D_DATETIME:
+                    cardViewItemProperty = new CardViewDatetimeItemModel(Object.assign(propertyDefinition, {
+                        multivalued: isMultiValued,
+                        pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]
+                    }));
+                    break;
+                case D_BOOLEAN:
+                    cardViewItemProperty = new CardViewBoolItemModel(propertyDefinition);
+                    break;
+                case D_TEXT:
+                default:
+                    cardViewItemProperty = new CardViewTextItemModel(Object.assign(propertyDefinition, {
+                        multivalued: isMultiValued,
+                        multiline: isMultiValued,
+                        pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]
+                    }));
+            }
+        }
+        return cardViewItemProperty;
+    }
+    isListOfValues(constraint) {
+        return constraint?.[0]?.type === 'LIST';
+    }
+    getPropertyConstraints(propertyName, definition) {
+        return definition?.properties.find((item) => item.id === propertyName)?.constraints ?? [];
+    }
+    checkECMTypeValidity(ecmPropertyType) {
+        if (RECOGNISED_ECM_TYPES.indexOf(ecmPropertyType) === -1) {
+            this.logService.error(`Unknown type for mapping: ${ecmPropertyType}`);
+        }
+    }
+    isEmpty(value) {
+        return value === undefined || value === null || value === '';
+    }
+    getDecimalNumberPipe() {
+        let decimalNumberPipe;
+        runInInjectionContext(this.injector, () => {
+            decimalNumberPipe = new DecimalNumberPipe(this.userPreferenceService, this.appConfig);
+        });
+        return decimalNumberPipe;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PropertyGroupTranslatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PropertyGroupTranslatorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PropertyGroupTranslatorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-groups-translator.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/content-metadata/services/property-groups-translator.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 { inject, Injectable, Injector, runInInjectionContext } from '@angular/core';\nimport {\n    AppConfigService,\n    CardViewBoolItemModel,\n    CardViewDateItemModel,\n    CardViewDatetimeItemModel,\n    CardViewFloatItemModel,\n    CardViewIntItemModel,\n    CardViewItem,\n    CardViewItemProperties,\n    CardViewLongItemModel,\n    CardViewSelectItemModel,\n    CardViewTextItemModel,\n    DecimalNumberPipe,\n    LogService,\n    MultiValuePipe,\n    UserPreferencesService\n} from '@alfresco/adf-core';\nimport { CardViewGroup, OrganisedPropertyGroup, Property } from '../interfaces/content-metadata.interfaces';\nimport { of } from 'rxjs';\nimport { Constraint, Definition, Property as PropertyBase } from '@alfresco/js-api';\n\nconst D_TEXT = 'd:text';\nconst D_MLTEXT = 'd:mltext';\nconst D_DATE = 'd:date';\nconst D_DATETIME = 'd:datetime';\nconst D_INT = 'd:int';\nconst D_LONG = 'd:long';\nconst D_FLOAT = 'd:float';\nconst D_DOUBLE = 'd:double';\nconst D_BOOLEAN = 'd:boolean';\n\nexport const RECOGNISED_ECM_TYPES = [D_TEXT, D_MLTEXT, D_DATE, D_DATETIME, D_INT, D_LONG, D_FLOAT, D_DOUBLE, D_BOOLEAN];\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PropertyGroupTranslatorService {\n    private userPreferenceService = inject(UserPreferencesService);\n    private appConfig = inject(AppConfigService);\n    private logService = inject(LogService);\n\n    valueSeparator: string;\n\n    private readonly injector = inject(Injector);\n\n    constructor() {\n        this.valueSeparator = this.appConfig.get<string>('content-metadata.multi-value-pipe-separator');\n    }\n\n    public translateToCardViewGroups(propertyGroups: OrganisedPropertyGroup[], propertyValues, definition: Definition): CardViewGroup[] {\n        return propertyGroups.map((propertyGroup) => {\n            const translatedPropertyGroup: any = Object.assign({}, propertyGroup);\n            translatedPropertyGroup.properties = this.translateArray(propertyGroup.properties, propertyValues, definition);\n            translatedPropertyGroup.editable = translatedPropertyGroup.properties.some((property) => property.editable);\n            return translatedPropertyGroup;\n        });\n    }\n\n    public translateProperty(property: PropertyBase, startValue?: any, allowEditing: boolean = false): CardViewItem {\n        this.checkECMTypeValidity(property.dataType);\n\n        const prefix = 'properties.';\n\n        const propertyDefinition: CardViewItemProperties = {\n            label: property.title || property.id,\n            value: startValue ? startValue : property.defaultValue,\n            key: `${prefix}${property.id}`,\n            default: property.defaultValue,\n            editable: property.isProtected ? false : allowEditing,\n            constraints: property?.constraints\n        };\n\n        return this.transform(propertyDefinition, property.dataType, property.isMultiValued);\n    }\n\n    private translateArray(properties: Property[], propertyValues: any, definition: Definition): CardViewItem[] {\n        return properties.map((property) => this.translate(property, propertyValues, this.getPropertyConstraints(property.name, definition)));\n    }\n\n    private translate(property: Property, propertyValues: any, constraints: Constraint[]): CardViewItem {\n        let propertyValue: any;\n        if (propertyValues && !this.isEmpty(propertyValues[property.name])) {\n            propertyValue = propertyValues[property.name];\n        }\n\n        this.checkECMTypeValidity(property.dataType);\n\n        const prefix = 'properties.';\n\n        const propertyDefinition: CardViewItemProperties = {\n            label: property.title || property.name,\n            value: propertyValue,\n            key: `${prefix}${property.name}`,\n            default: property.defaultValue,\n            editable: property.protected ? false : property.editable !== undefined ? property.editable : true,\n            constraints\n        };\n\n        return this.transform(propertyDefinition, property.dataType, property.multiValued);\n    }\n\n    private transform(propertyDefinition: CardViewItemProperties, dataType: string, isMultiValued: boolean): CardViewItem {\n        let cardViewItemProperty: CardViewItem;\n\n        if (this.isListOfValues(propertyDefinition.constraints)) {\n            const options = propertyDefinition.constraints[0].parameters.allowedValues.map((value) => ({ key: value, label: value }));\n            const properties = Object.assign(propertyDefinition, { options$: of(options) });\n\n            cardViewItemProperty = new CardViewSelectItemModel(properties);\n        } else {\n            switch (dataType) {\n                case D_MLTEXT:\n                    cardViewItemProperty = new CardViewTextItemModel(\n                        Object.assign(propertyDefinition, {\n                            multiline: true\n                        })\n                    );\n                    break;\n\n                case D_INT:\n                    cardViewItemProperty = new CardViewIntItemModel(\n                        Object.assign(propertyDefinition, {\n                            multivalued: isMultiValued,\n                            pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]\n                        })\n                    );\n                    break;\n\n                case D_LONG:\n                    cardViewItemProperty = new CardViewLongItemModel(\n                        Object.assign(propertyDefinition, {\n                            multivalued: isMultiValued,\n                            pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]\n                        })\n                    );\n                    break;\n\n                case D_FLOAT:\n                case D_DOUBLE:\n                    cardViewItemProperty = new CardViewFloatItemModel(\n                        Object.assign(propertyDefinition, {\n                            multivalued: isMultiValued,\n                            pipes: [{ pipe: this.getDecimalNumberPipe() }, { pipe: new MultiValuePipe(), params: [this.valueSeparator] }]\n                        })\n                    );\n                    break;\n\n                case D_DATE:\n                    cardViewItemProperty = new CardViewDateItemModel(\n                        Object.assign(propertyDefinition, {\n                            multivalued: isMultiValued,\n                            pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]\n                        })\n                    );\n                    break;\n\n                case D_DATETIME:\n                    cardViewItemProperty = new CardViewDatetimeItemModel(\n                        Object.assign(propertyDefinition, {\n                            multivalued: isMultiValued,\n                            pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]\n                        })\n                    );\n                    break;\n\n                case D_BOOLEAN:\n                    cardViewItemProperty = new CardViewBoolItemModel(propertyDefinition);\n                    break;\n\n                case D_TEXT:\n                default:\n                    cardViewItemProperty = new CardViewTextItemModel(\n                        Object.assign(propertyDefinition, {\n                            multivalued: isMultiValued,\n                            multiline: isMultiValued,\n                            pipes: [{ pipe: new MultiValuePipe(), params: [this.valueSeparator] }]\n                        })\n                    );\n            }\n        }\n\n        return cardViewItemProperty;\n    }\n\n    private isListOfValues(constraint: Constraint[]): boolean {\n        return constraint?.[0]?.type === 'LIST';\n    }\n\n    private getPropertyConstraints(propertyName: string, definition: Definition): Constraint[] {\n        return definition?.properties.find((item) => item.id === propertyName)?.constraints ?? [];\n    }\n\n    private checkECMTypeValidity(ecmPropertyType: string) {\n        if (RECOGNISED_ECM_TYPES.indexOf(ecmPropertyType) === -1) {\n            this.logService.error(`Unknown type for mapping: ${ecmPropertyType}`);\n        }\n    }\n\n    private isEmpty(value: any): boolean {\n        return value === undefined || value === null || value === '';\n    }\n\n    private getDecimalNumberPipe(): DecimalNumberPipe {\n        let decimalNumberPipe: DecimalNumberPipe;\n        runInInjectionContext(this.injector, () => {\n            decimalNumberPipe = new DecimalNumberPipe(this.userPreferenceService, this.appConfig);\n        });\n        return decimalNumberPipe;\n    }\n}\n"]}