@alfresco/adf-content-services 8.1.0-15469386840 → 8.1.0-15484232623

package/esm2022/lib/tag/services/tag.service.mjs

@@ -0,0 +1,171 @@
+/*!
+ * @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 { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { AppConfigService, UserPreferencesService } from '@alfresco/adf-core';
+import { EventEmitter, Injectable, Output } from '@angular/core';
+import { from } from 'rxjs';
+import { map, tap } from 'rxjs/operators';
+import { TagBody, TagsApi } from '@alfresco/js-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export class TagService {
+    get tagsApi() {
+        this._tagsApi = this._tagsApi ?? new TagsApi(this.apiService.getInstance());
+        return this._tagsApi;
+    }
+    constructor(apiService, userPreferencesService, appConfigService) {
+        this.apiService = apiService;
+        this.userPreferencesService = userPreferencesService;
+        this.appConfigService = appConfigService;
+        /** Emitted when tag information is updated. */
+        this.refresh = new EventEmitter();
+    }
+    /**
+     * Gets a list of tags added to a node.
+     *
+     * @param nodeId ID of the target node
+     * @returns TagPaging object (defined in JS-API) containing the tags
+     */
+    getTagsByNodeId(nodeId) {
+        return from(this.tagsApi.listTagsForNode(nodeId));
+    }
+    /**
+     * Gets a list of all the tags already defined in the repository.
+     *
+     * @param opts Options supported by JS-API
+     * @param includedCounts True if count field should be included in response object for each tag, false otherwise.
+     * @returns TagPaging object (defined in JS-API) containing the tags
+     */
+    getAllTheTags(opts, includedCounts) {
+        return from(this.tagsApi.listTags({
+            include: includedCounts ? ['count'] : undefined,
+            ...opts
+        }));
+    }
+    /**
+     * Adds a tag to a node.
+     *
+     * @param nodeId ID of the target node
+     * @param tagName Name of the tag to add
+     * @returns TagEntry object (defined in JS-API) with details of the new tag
+     */
+    addTag(nodeId, tagName) {
+        const tagBody = new TagBody();
+        tagBody.tag = tagName;
+        return from(this.tagsApi.createTagForNode(nodeId, [tagBody])).pipe(tap((tagEntry) => this.refresh.emit(tagEntry)));
+    }
+    /**
+     * Removes a tag from a node.
+     *
+     * @param nodeId ID of the target node
+     * @param tag Name of the tag to remove
+     * @returns Null object when the operation completes
+     */
+    removeTag(nodeId, tag) {
+        return from(this.tagsApi.deleteTagFromNode(nodeId, tag)).pipe(tap(() => this.refresh.emit()));
+    }
+    /**
+     * Creates tags.
+     *
+     * @param tags list of tags to create.
+     * @returns Created tags.
+     */
+    createTags(tags) {
+        return from(this.tagsApi.createTags(tags)).pipe(tap((tagEntries) => this.refresh.emit(tagEntries)));
+    }
+    /**
+     * Update a tag
+     *
+     * @param tagId The identifier of a tag.
+     * @param tagBody The updated tag.
+     * @returns Updated tag.
+     */
+    updateTag(tagId, tagBody) {
+        return from(this.tagsApi.updateTag(tagId, tagBody)).pipe(tap((tagEntry) => this.refresh.emit(tagEntry)));
+    }
+    /**
+     * Find tags which name contains searched name.
+     *
+     * @param name Value for name which should be used during searching tags.
+     * @param sorting Object which configures sorting. OrderBy field specifies field used for sorting, direction specified ascending or descending direction.
+     * Default sorting is ascending by tag field.
+     * @param includedCounts True if count field should be included in response object for each tag, false otherwise.
+     * @param skipCount Specify how many first results should be skipped. Default 0.
+     * @param maxItems Specify max number of returned tags. Default is specified by UserPreferencesService.
+     * @returns Found tags which name contains searched name.
+     */
+    searchTags(name, sorting = { orderBy: 'tag', direction: 'asc' }, includedCounts, skipCount = 0, maxItems) {
+        maxItems = maxItems || this.userPreferencesService.paginationSize;
+        return this.getAllTheTags({
+            tag: `*${name}*`,
+            skipCount,
+            maxItems,
+            sorting,
+            matching: true
+        }, includedCounts);
+    }
+    /**
+     * Find tag which name matches exactly to passed name.
+     *
+     * @param name Value for name which should be used during finding exact tag.
+     * @returns Found tag which name matches exactly to passed name.
+     */
+    findTagByName(name) {
+        return this.getAllTheTags({ tag: name }).pipe(map((result) => result.list.entries[0]));
+    }
+    /**
+     * Deletes a tag with tagId.
+     * This will cause the tag to be removed from all nodes.
+     * You must have admin rights to delete a tag.
+     *
+     * @param tagId of the tag to be deleted
+     * @returns Null object when the operation completes
+     */
+    deleteTag(tagId) {
+        return from(this.tagsApi.deleteTag(tagId)).pipe(tap(() => this.refresh.emit()));
+    }
+    /**
+     * Assign tags to node. If tag is new then tag is also created additionally, if tag already exists then it is just assigned.
+     *
+     * @param nodeId Id of node to which tags should be assigned.
+     * @param tags List of tags to create and assign or just assign if they already exist.
+     * @returns Just linked tags to node or single tag if linked only one tag.
+     */
+    assignTagsToNode(nodeId, tags) {
+        return from(this.tagsApi.assignTagsToNode(nodeId, tags)).pipe(tap((data) => this.refresh.emit(data)));
+    }
+    /**
+     * Checks if tags plugin is enabled.
+     *
+     * @returns boolean true if tags plugin is enabled, false otherwise.
+     */
+    areTagsEnabled() {
+        return this.appConfigService.get('plugins.tagsEnabled', true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.UserPreferencesService }, { token: i2.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.UserPreferencesService }, { type: i2.AppConfigService }], propDecorators: { refresh: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tag.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tag/services/tag.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 { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport { AppConfigService, UserPreferencesService } from '@alfresco/adf-core';\nimport { EventEmitter, Injectable, Output } from '@angular/core';\nimport { from, Observable } from 'rxjs';\nimport { map, tap } from 'rxjs/operators';\nimport { TagBody, TagEntry, TagPaging, TagsApi } from '@alfresco/js-api';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class TagService {\n    private _tagsApi: TagsApi;\n    get tagsApi(): TagsApi {\n        this._tagsApi = this._tagsApi ?? new TagsApi(this.apiService.getInstance());\n        return this._tagsApi;\n    }\n\n    /** Emitted when tag information is updated. */\n    @Output()\n    refresh = new EventEmitter();\n\n    constructor(\n        private apiService: AlfrescoApiService,\n        private userPreferencesService: UserPreferencesService,\n        private appConfigService: AppConfigService\n    ) {}\n\n    /**\n     * Gets a list of tags added to a node.\n     *\n     * @param nodeId ID of the target node\n     * @returns TagPaging object (defined in JS-API) containing the tags\n     */\n    getTagsByNodeId(nodeId: string): Observable<TagPaging> {\n        return from(this.tagsApi.listTagsForNode(nodeId));\n    }\n\n    /**\n     * Gets a list of all the tags already defined in the repository.\n     *\n     * @param opts Options supported by JS-API\n     * @param includedCounts True if count field should be included in response object for each tag, false otherwise.\n     * @returns TagPaging object (defined in JS-API) containing the tags\n     */\n    getAllTheTags(opts?: any, includedCounts?: boolean): Observable<TagPaging> {\n        return from(\n            this.tagsApi.listTags({\n                include: includedCounts ? ['count'] : undefined,\n                ...opts\n            })\n        );\n    }\n\n    /**\n     * Adds a tag to a node.\n     *\n     * @param nodeId ID of the target node\n     * @param tagName Name of the tag to add\n     * @returns TagEntry object (defined in JS-API) with details of the new tag\n     */\n    addTag(nodeId: string, tagName: string): Observable<TagEntry> {\n        const tagBody = new TagBody();\n        tagBody.tag = tagName;\n\n        return from(this.tagsApi.createTagForNode(nodeId, [tagBody])).pipe(tap((tagEntry) => this.refresh.emit(tagEntry)));\n    }\n\n    /**\n     * Removes a tag from a node.\n     *\n     * @param nodeId ID of the target node\n     * @param tag Name of the tag to remove\n     * @returns Null object when the operation completes\n     */\n    removeTag(nodeId: string, tag: string): Observable<void> {\n        return from(this.tagsApi.deleteTagFromNode(nodeId, tag)).pipe(tap(() => this.refresh.emit()));\n    }\n\n    /**\n     * Creates tags.\n     *\n     * @param tags list of tags to create.\n     * @returns Created tags.\n     */\n    createTags(tags: TagBody[]): Observable<TagEntry | TagPaging> {\n        return from(this.tagsApi.createTags(tags)).pipe(tap((tagEntries) => this.refresh.emit(tagEntries)));\n    }\n\n    /**\n     * Update a tag\n     *\n     * @param tagId The identifier of a tag.\n     * @param tagBody The updated tag.\n     * @returns Updated tag.\n     */\n    updateTag(tagId: string, tagBody: TagBody): Observable<TagEntry> {\n        return from(this.tagsApi.updateTag(tagId, tagBody)).pipe(tap((tagEntry) => this.refresh.emit(tagEntry)));\n    }\n\n    /**\n     * Find tags which name contains searched name.\n     *\n     * @param name Value for name which should be used during searching tags.\n     * @param sorting Object which configures sorting. OrderBy field specifies field used for sorting, direction specified ascending or descending direction.\n     * Default sorting is ascending by tag field.\n     * @param includedCounts True if count field should be included in response object for each tag, false otherwise.\n     * @param skipCount Specify how many first results should be skipped. Default 0.\n     * @param maxItems Specify max number of returned tags. Default is specified by UserPreferencesService.\n     * @returns Found tags which name contains searched name.\n     */\n    searchTags(\n        name: string,\n        sorting = { orderBy: 'tag', direction: 'asc' },\n        includedCounts?: boolean,\n        skipCount = 0,\n        maxItems?: number\n    ): Observable<TagPaging> {\n        maxItems = maxItems || this.userPreferencesService.paginationSize;\n        return this.getAllTheTags(\n            {\n                tag: `*${name}*`,\n                skipCount,\n                maxItems,\n                sorting,\n                matching: true\n            },\n            includedCounts\n        );\n    }\n\n    /**\n     * Find tag which name matches exactly to passed name.\n     *\n     * @param name Value for name which should be used during finding exact tag.\n     * @returns Found tag which name matches exactly to passed name.\n     */\n    findTagByName(name: string): Observable<TagEntry> {\n        return this.getAllTheTags({ tag: name }).pipe(map((result) => result.list.entries[0]));\n    }\n\n    /**\n     * Deletes a tag with tagId.\n     * This will cause the tag to be removed from all nodes.\n     * You must have admin rights to delete a tag.\n     *\n     * @param tagId of the tag to be deleted\n     * @returns Null object when the operation completes\n     */\n    deleteTag(tagId: string): Observable<void> {\n        return from(this.tagsApi.deleteTag(tagId)).pipe(tap(() => this.refresh.emit()));\n    }\n\n    /**\n     * Assign tags to node. If tag is new then tag is also created additionally, if tag already exists then it is just assigned.\n     *\n     * @param nodeId Id of node to which tags should be assigned.\n     * @param tags List of tags to create and assign or just assign if they already exist.\n     * @returns Just linked tags to node or single tag if linked only one tag.\n     */\n    assignTagsToNode(nodeId: string, tags: TagBody[]): Observable<TagPaging | TagEntry> {\n        return from(this.tagsApi.assignTagsToNode(nodeId, tags)).pipe(tap((data) => this.refresh.emit(data)));\n    }\n\n    /**\n     * Checks if tags plugin is enabled.\n     *\n     * @returns boolean true if tags plugin is enabled, false otherwise.\n     */\n    areTagsEnabled(): boolean {\n        return this.appConfigService.get('plugins.tagsEnabled', true);\n    }\n}\n"]}

package/esm2022/lib/tag/tag-actions/tag-actions.component.mjs

@@ -0,0 +1,115 @@
+/*!
+ * @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 { Component, DestroyRef, EventEmitter, inject, Input, Output, ViewEncapsulation } from '@angular/core';
+import { TagService } from '../services/tag.service';
+import { CommonModule } from '@angular/common';
+import { MatListModule } from '@angular/material/list';
+import { MatIconModule } from '@angular/material/icon';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { TranslateModule } from '@ngx-translate/core';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/tag.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/list";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@ngx-translate/core";
+import * as i9 from "@angular/forms";
+import * as i10 from "@angular/material/button";
+/**
+ *
+ * This component, provide a list of the tags relative a node with actions button to add or remove new tag
+ */
+export class TagActionsComponent {
+    constructor(tagService, translateService) {
+        this.tagService = tagService;
+        this.translateService = translateService;
+        /** Emitted when a tag is added successfully. */
+        this.successAdd = new EventEmitter();
+        /** Emitted when an error occurs. */
+        this.error = new EventEmitter();
+        /** Emitted when an action is chosen. */
+        this.result = new EventEmitter();
+        this.disableAddTag = true;
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.tagService.refresh.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.refreshTag());
+    }
+    ngOnChanges() {
+        return this.refreshTag();
+    }
+    refreshTag() {
+        if (this.nodeId) {
+            this.tagService.getTagsByNodeId(this.nodeId).subscribe((tagPaging) => {
+                this.tagsEntries = tagPaging.list.entries;
+                this.disableAddTag = false;
+                this.result.emit(this.tagsEntries);
+            }, () => {
+                this.tagsEntries = null;
+                this.disableAddTag = true;
+                this.result.emit(this.tagsEntries);
+            });
+        }
+    }
+    addTag() {
+        if (this.searchTag(this.newTagName)) {
+            this.errorMsg = this.translateService.instant('TAG.MESSAGES.EXIST');
+            this.error.emit(this.errorMsg);
+        }
+        else {
+            this.tagService.addTag(this.nodeId, this.newTagName).subscribe(() => {
+                this.newTagName = '';
+                this.successAdd.emit(this.nodeId);
+            });
+        }
+    }
+    searchTag(searchTagName) {
+        if (this.tagsEntries) {
+            return this.tagsEntries.find((currentTag) => searchTagName === currentTag.entry.tag);
+        }
+    }
+    cleanErrorMsg() {
+        this.errorMsg = '';
+    }
+    removeTag(tag) {
+        this.tagService.removeTag(this.nodeId, tag);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagActionsComponent, deps: [{ token: i1.TagService }, { token: i2.TranslationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TagActionsComponent, isStandalone: true, selector: "adf-tag-node-actions-list", inputs: { nodeId: "nodeId" }, outputs: { successAdd: "successAdd", error: "error", result: "result" }, host: { classAttribute: "adf-tag-node-actions-list" }, usesOnChanges: true, ngImport: i0, template: "<mat-list>\n    <mat-list-item *ngFor=\"let currentEntry of tagsEntries; let idx = index\">\n        <div\n            class=\"adf-tag-actions-container\"\n            id=\"tag_delete_{{ currentEntry.entry.tag }}\"\n            tabindex=\"0\"\n            role=\"button\"\n            (keyup.enter)=\"removeTag(currentEntry.entry.id)\"\n            (click)=\"removeTag(currentEntry.entry.id)\"\n        >\n            <div class=\"adf-tag-actions-delete-text\" id=\"tag_name_{{ currentEntry.entry.tag }}\">{{ currentEntry.entry.tag }}</div>\n            <mat-icon class=\"adf-tag-actions-delete-icon\">delete</mat-icon>\n        </div>\n    </mat-list-item>\n</mat-list>\n<table class=\"adf-full-width\" cellspacing=\"0\">\n    <tr>\n        <td>\n            <mat-form-field class=\"adf-full-width\">\n                <input\n                    id=\"new-tag-text\"\n                    matInput\n                    placeholder=\"{{ 'TAG.LABEL.NEWTAG' | translate }}\"\n                    type=\"text\"\n                    (keypress)=\"cleanErrorMsg()\"\n                    [(ngModel)]=\"newTagName\"\n                />\n                <mat-hint data-automation-id=\"errorMessage\" *ngIf=\"error\" [ngStyle]=\"{ color: 'red' }\" align=\"start\">{{ errorMsg }} </mat-hint>\n            </mat-form-field>\n        </td>\n        <td>\n            <button id=\"add-tag\" class=\"adf-full-width\" color=\"primary\" (click)=\"addTag()\" [disabled]=\"disableAddTag\" mat-raised-button>\n                {{ 'TAG.BUTTON.ADD' | translate }}\n            </button>\n        </td>\n    </tr>\n</table>\n", styles: [".adf-tag-node-actions-list .adf-full-width{width:100%}.adf-tag-node-actions-list .adf-tag-actions-delete-icon{float:right;cursor:pointer}.adf-tag-node-actions-list .adf-tag-actions-delete-text{font-size:var(--theme-subheading-2-font-size);float:left}.adf-tag-node-actions-list .adf-tag-actions-container{padding:8px 0;height:20px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i4.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i4.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i6.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i9.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i9.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i9.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i10.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-tag-node-actions-list', standalone: true, imports: [CommonModule, MatListModule, MatIconModule, MatFormFieldModule, MatInputModule, TranslateModule, FormsModule, MatButtonModule], encapsulation: ViewEncapsulation.None, host: { class: 'adf-tag-node-actions-list' }, template: "<mat-list>\n    <mat-list-item *ngFor=\"let currentEntry of tagsEntries; let idx = index\">\n        <div\n            class=\"adf-tag-actions-container\"\n            id=\"tag_delete_{{ currentEntry.entry.tag }}\"\n            tabindex=\"0\"\n            role=\"button\"\n            (keyup.enter)=\"removeTag(currentEntry.entry.id)\"\n            (click)=\"removeTag(currentEntry.entry.id)\"\n        >\n            <div class=\"adf-tag-actions-delete-text\" id=\"tag_name_{{ currentEntry.entry.tag }}\">{{ currentEntry.entry.tag }}</div>\n            <mat-icon class=\"adf-tag-actions-delete-icon\">delete</mat-icon>\n        </div>\n    </mat-list-item>\n</mat-list>\n<table class=\"adf-full-width\" cellspacing=\"0\">\n    <tr>\n        <td>\n            <mat-form-field class=\"adf-full-width\">\n                <input\n                    id=\"new-tag-text\"\n                    matInput\n                    placeholder=\"{{ 'TAG.LABEL.NEWTAG' | translate }}\"\n                    type=\"text\"\n                    (keypress)=\"cleanErrorMsg()\"\n                    [(ngModel)]=\"newTagName\"\n                />\n                <mat-hint data-automation-id=\"errorMessage\" *ngIf=\"error\" [ngStyle]=\"{ color: 'red' }\" align=\"start\">{{ errorMsg }} </mat-hint>\n            </mat-form-field>\n        </td>\n        <td>\n            <button id=\"add-tag\" class=\"adf-full-width\" color=\"primary\" (click)=\"addTag()\" [disabled]=\"disableAddTag\" mat-raised-button>\n                {{ 'TAG.BUTTON.ADD' | translate }}\n            </button>\n        </td>\n    </tr>\n</table>\n", styles: [".adf-tag-node-actions-list .adf-full-width{width:100%}.adf-tag-node-actions-list .adf-tag-actions-delete-icon{float:right;cursor:pointer}.adf-tag-node-actions-list .adf-tag-actions-delete-text{font-size:var(--theme-subheading-2-font-size);float:left}.adf-tag-node-actions-list .adf-tag-actions-container{padding:8px 0;height:20px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TagService }, { type: i2.TranslationService }], propDecorators: { nodeId: [{
+                type: Input,
+                args: [{ required: true }]
+            }], successAdd: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], result: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tag-actions.component.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tag/tag-actions/tag-actions.component.ts","../../../../../../../lib/content-services/src/lib/tag/tag-actions/tag-actions.component.html"],"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 { Component, DestroyRef, EventEmitter, inject, Input, OnChanges, OnInit, Output, ViewEncapsulation } from '@angular/core';\nimport { TagService } from '../services/tag.service';\nimport { TagPaging } from '@alfresco/js-api';\nimport { CommonModule } from '@angular/common';\nimport { MatListModule } from '@angular/material/list';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatInputModule } from '@angular/material/input';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { FormsModule } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n/**\n *\n * This component, provide a list of the tags relative a node with actions button to add or remove new tag\n */\n\n@Component({\n    selector: 'adf-tag-node-actions-list',\n    standalone: true,\n    imports: [CommonModule, MatListModule, MatIconModule, MatFormFieldModule, MatInputModule, TranslateModule, FormsModule, MatButtonModule],\n    templateUrl: './tag-actions.component.html',\n    styleUrls: ['./tag-actions.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-tag-node-actions-list' }\n})\nexport class TagActionsComponent implements OnChanges, OnInit {\n    /** The identifier of a node. */\n    @Input({ required: true })\n    nodeId: string;\n\n    /** Emitted when a tag is added successfully. */\n    @Output()\n    successAdd: EventEmitter<any> = new EventEmitter();\n\n    /** Emitted when an error occurs. */\n    @Output()\n    error: EventEmitter<any> = new EventEmitter();\n\n    /** Emitted when an action is chosen. */\n    @Output()\n    result = new EventEmitter();\n\n    newTagName: string;\n    tagsEntries: any;\n    errorMsg: string;\n    disableAddTag: boolean = true;\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    constructor(private tagService: TagService, private translateService: TranslationService) {}\n\n    ngOnInit() {\n        this.tagService.refresh.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.refreshTag());\n    }\n\n    ngOnChanges() {\n        return this.refreshTag();\n    }\n\n    refreshTag() {\n        if (this.nodeId) {\n            this.tagService.getTagsByNodeId(this.nodeId).subscribe(\n                (tagPaging: TagPaging) => {\n                    this.tagsEntries = tagPaging.list.entries;\n                    this.disableAddTag = false;\n                    this.result.emit(this.tagsEntries);\n                },\n                () => {\n                    this.tagsEntries = null;\n                    this.disableAddTag = true;\n                    this.result.emit(this.tagsEntries);\n                }\n            );\n        }\n    }\n\n    addTag() {\n        if (this.searchTag(this.newTagName)) {\n            this.errorMsg = this.translateService.instant('TAG.MESSAGES.EXIST');\n            this.error.emit(this.errorMsg);\n        } else {\n            this.tagService.addTag(this.nodeId, this.newTagName).subscribe(() => {\n                this.newTagName = '';\n                this.successAdd.emit(this.nodeId);\n            });\n        }\n    }\n\n    searchTag(searchTagName: string) {\n        if (this.tagsEntries) {\n            return this.tagsEntries.find((currentTag) => searchTagName === currentTag.entry.tag);\n        }\n    }\n\n    cleanErrorMsg() {\n        this.errorMsg = '';\n    }\n\n    removeTag(tag: string) {\n        this.tagService.removeTag(this.nodeId, tag);\n    }\n}\n","<mat-list>\n    <mat-list-item *ngFor=\"let currentEntry of tagsEntries; let idx = index\">\n        <div\n            class=\"adf-tag-actions-container\"\n            id=\"tag_delete_{{ currentEntry.entry.tag }}\"\n            tabindex=\"0\"\n            role=\"button\"\n            (keyup.enter)=\"removeTag(currentEntry.entry.id)\"\n            (click)=\"removeTag(currentEntry.entry.id)\"\n        >\n            <div class=\"adf-tag-actions-delete-text\" id=\"tag_name_{{ currentEntry.entry.tag }}\">{{ currentEntry.entry.tag }}</div>\n            <mat-icon class=\"adf-tag-actions-delete-icon\">delete</mat-icon>\n        </div>\n    </mat-list-item>\n</mat-list>\n<table class=\"adf-full-width\" cellspacing=\"0\">\n    <tr>\n        <td>\n            <mat-form-field class=\"adf-full-width\">\n                <input\n                    id=\"new-tag-text\"\n                    matInput\n                    placeholder=\"{{ 'TAG.LABEL.NEWTAG' | translate }}\"\n                    type=\"text\"\n                    (keypress)=\"cleanErrorMsg()\"\n                    [(ngModel)]=\"newTagName\"\n                />\n                <mat-hint data-automation-id=\"errorMessage\" *ngIf=\"error\" [ngStyle]=\"{ color: 'red' }\" align=\"start\">{{ errorMsg }} </mat-hint>\n            </mat-form-field>\n        </td>\n        <td>\n            <button id=\"add-tag\" class=\"adf-full-width\" color=\"primary\" (click)=\"addTag()\" [disabled]=\"disableAddTag\" mat-raised-button>\n                {{ 'TAG.BUTTON.ADD' | translate }}\n            </button>\n        </td>\n    </tr>\n</table>\n"]}

package/esm2022/lib/tag/tag-list/tag-list.component.mjs

@@ -0,0 +1,98 @@
+/*!
+ * @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 { Component, EventEmitter, Output, ViewEncapsulation } from '@angular/core';
+import { TagService } from '../services/tag.service';
+import { CommonModule } from '@angular/common';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/tag.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/chips";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+/**
+ * This component provide a list of all the tag inside the ECM
+ */
+export class TagListComponent {
+    constructor(tagService) {
+        this.tagService = tagService;
+        /** Emitted when a tag is selected. */
+        this.result = new EventEmitter();
+        /**
+         * Array of tags that are displayed
+         */
+        this.tagsEntries = [];
+        /**
+         * Number of items per iteration
+         */
+        this.size = 10;
+        this.isLoading = false;
+        this.isSizeMinimum = true;
+        this.defaultPagination = {
+            skipCount: 0,
+            maxItems: this.size,
+            hasMoreItems: false
+        };
+        this.pagination = this.defaultPagination;
+        this.tagService.refresh.pipe(takeUntilDestroyed()).subscribe(() => {
+            this.tagsEntries = [];
+            this.refreshTag(this.defaultPagination);
+        });
+    }
+    ngOnInit() {
+        this.refreshTag(this.defaultPagination);
+    }
+    refreshTag(opts) {
+        this.tagService.getAllTheTags(opts).subscribe((tags) => {
+            this.tagsEntries = this.tagsEntries.concat(tags.list.entries);
+            this.pagination = tags.list.pagination;
+            this.result.emit(this.tagsEntries);
+            this.isLoading = false;
+        });
+    }
+    loadMoreTags() {
+        if (this.pagination.hasMoreItems) {
+            this.isLoading = true;
+            this.isSizeMinimum = false;
+            this.refreshTag({
+                skipCount: this.pagination.skipCount + this.pagination.count,
+                maxItems: this.size
+            });
+        }
+    }
+    loadLessTags() {
+        this.isSizeMinimum = false;
+        this.tagsEntries = this.tagsEntries.slice(0, this.tagsEntries.length - this.pagination.count);
+        this.pagination.skipCount = this.pagination.skipCount - this.pagination.count;
+        this.pagination.hasMoreItems = true;
+        if (this.tagsEntries.length <= this.size) {
+            this.isSizeMinimum = true;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagListComponent, deps: [{ token: i1.TagService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TagListComponent, isStandalone: true, selector: "adf-tag-list", outputs: { result: "result" }, host: { classAttribute: "adf-tag-list" }, ngImport: i0, template: "<mat-chip-listbox class=\"adf-tag-chips-list\">\n    <div class=\"adf-list-tag\" *ngFor=\"let currentEntry of tagsEntries; let idx = index\">\n        <mat-chip-option class=\"adf-tag-list-chip\">\n            <span id=\"tag_name_{{idx}}\">{{currentEntry.entry.tag}}</span>\n        </mat-chip-option>\n    </div>\n</mat-chip-listbox>\n\n<div class=\"adf-tag-list-controls\">\n    <button\n        *ngIf=\"!isSizeMinimum\"\n        [disabled]=\"isLoading\"\n        data-automation-id=\"show-fewer-tags\"\n        mat-icon-button\n        (click)=\"loadLessTags()\">\n        <mat-icon>keyboard_arrow_up</mat-icon>\n    </button>\n    <button\n        *ngIf=\"pagination.hasMoreItems\"\n        [disabled]=\"isLoading\"\n        data-automation-id=\"show-more-tags\"\n        mat-icon-button\n        (click)=\"loadMoreTags()\">\n        <mat-icon>keyboard_arrow_down</mat-icon>\n    </button>\n</div>\n", styles: [".adf-tag-list .adf-tag-chips-list,.adf-tag-list .adf-tag-chips-list div{display:flex;flex-direction:column}.adf-tag-list .adf-tag-chips-list .adf-list-tag{display:block;font-size:var(--theme-subheading-2-font-size)}.adf-tag-list .adf-tag-chips-list .adf-list-tag .adf-tag-list-chip{color:var(--theme-primary-color-default-contrast);background-color:var(--theme-primary-color)}.adf-tag-list .adf-tag-list-controls{margin-top:30px;display:flex;justify-content:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatChipsModule }, { kind: "component", type: i3.MatChipListbox, selector: "mat-chip-listbox", inputs: ["multiple", "aria-orientation", "selectable", "compareWith", "required", "hideSingleSelectionIndicator", "value"], outputs: ["change"] }, { kind: "component", type: i3.MatChipOption, selector: "mat-basic-chip-option, [mat-basic-chip-option], mat-chip-option, [mat-chip-option]", inputs: ["selectable", "selected"], outputs: ["selectionChange"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-tag-list', standalone: true, imports: [CommonModule, MatChipsModule, MatButtonModule, MatIconModule], encapsulation: ViewEncapsulation.None, host: { class: 'adf-tag-list' }, template: "<mat-chip-listbox class=\"adf-tag-chips-list\">\n    <div class=\"adf-list-tag\" *ngFor=\"let currentEntry of tagsEntries; let idx = index\">\n        <mat-chip-option class=\"adf-tag-list-chip\">\n            <span id=\"tag_name_{{idx}}\">{{currentEntry.entry.tag}}</span>\n        </mat-chip-option>\n    </div>\n</mat-chip-listbox>\n\n<div class=\"adf-tag-list-controls\">\n    <button\n        *ngIf=\"!isSizeMinimum\"\n        [disabled]=\"isLoading\"\n        data-automation-id=\"show-fewer-tags\"\n        mat-icon-button\n        (click)=\"loadLessTags()\">\n        <mat-icon>keyboard_arrow_up</mat-icon>\n    </button>\n    <button\n        *ngIf=\"pagination.hasMoreItems\"\n        [disabled]=\"isLoading\"\n        data-automation-id=\"show-more-tags\"\n        mat-icon-button\n        (click)=\"loadMoreTags()\">\n        <mat-icon>keyboard_arrow_down</mat-icon>\n    </button>\n</div>\n", styles: [".adf-tag-list .adf-tag-chips-list,.adf-tag-list .adf-tag-chips-list div{display:flex;flex-direction:column}.adf-tag-list .adf-tag-chips-list .adf-list-tag{display:block;font-size:var(--theme-subheading-2-font-size)}.adf-tag-list .adf-tag-chips-list .adf-list-tag .adf-tag-list-chip{color:var(--theme-primary-color-default-contrast);background-color:var(--theme-primary-color)}.adf-tag-list .adf-tag-list-controls{margin-top:30px;display:flex;justify-content:center}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TagService }], propDecorators: { result: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tag-list.component.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tag/tag-list/tag-list.component.ts","../../../../../../../lib/content-services/src/lib/tag/tag-list/tag-list.component.html"],"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 { Component, EventEmitter, OnInit, Output, ViewEncapsulation } from '@angular/core';\nimport { TagService } from '../services/tag.service';\nimport { PaginationModel } from '@alfresco/adf-core';\nimport { TagEntry } from '@alfresco/js-api';\nimport { CommonModule } from '@angular/common';\nimport { MatChipsModule } from '@angular/material/chips';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n/**\n * This component provide a list of all the tag inside the ECM\n */\n@Component({\n    selector: 'adf-tag-list',\n    standalone: true,\n    imports: [CommonModule, MatChipsModule, MatButtonModule, MatIconModule],\n    templateUrl: './tag-list.component.html',\n    styleUrls: ['./tag-list.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-tag-list' }\n})\nexport class TagListComponent implements OnInit {\n    /** Emitted when a tag is selected. */\n    @Output()\n    result = new EventEmitter();\n\n    /**\n     * Array of tags that are displayed\n     */\n    tagsEntries: TagEntry[] = [];\n\n    /**\n     * Number of items per iteration\n     */\n    size: number = 10;\n\n    defaultPagination: PaginationModel;\n    pagination: PaginationModel;\n\n    isLoading = false;\n    isSizeMinimum = true;\n\n    constructor(private tagService: TagService) {\n        this.defaultPagination = {\n            skipCount: 0,\n            maxItems: this.size,\n            hasMoreItems: false\n        };\n\n        this.pagination = this.defaultPagination;\n\n        this.tagService.refresh.pipe(takeUntilDestroyed()).subscribe(() => {\n            this.tagsEntries = [];\n            this.refreshTag(this.defaultPagination);\n        });\n    }\n\n    ngOnInit() {\n        this.refreshTag(this.defaultPagination);\n    }\n    refreshTag(opts?: any) {\n        this.tagService.getAllTheTags(opts).subscribe((tags) => {\n            this.tagsEntries = this.tagsEntries.concat(tags.list.entries);\n            this.pagination = tags.list.pagination;\n            this.result.emit(this.tagsEntries);\n            this.isLoading = false;\n        });\n    }\n\n    loadMoreTags() {\n        if (this.pagination.hasMoreItems) {\n            this.isLoading = true;\n            this.isSizeMinimum = false;\n\n            this.refreshTag({\n                skipCount: this.pagination.skipCount + this.pagination.count,\n                maxItems: this.size\n            });\n        }\n    }\n\n    loadLessTags() {\n        this.isSizeMinimum = false;\n        this.tagsEntries = this.tagsEntries.slice(0, this.tagsEntries.length - this.pagination.count);\n        this.pagination.skipCount = this.pagination.skipCount - this.pagination.count;\n        this.pagination.hasMoreItems = true;\n\n        if (this.tagsEntries.length <= this.size) {\n            this.isSizeMinimum = true;\n        }\n    }\n}\n","<mat-chip-listbox class=\"adf-tag-chips-list\">\n    <div class=\"adf-list-tag\" *ngFor=\"let currentEntry of tagsEntries; let idx = index\">\n        <mat-chip-option class=\"adf-tag-list-chip\">\n            <span id=\"tag_name_{{idx}}\">{{currentEntry.entry.tag}}</span>\n        </mat-chip-option>\n    </div>\n</mat-chip-listbox>\n\n<div class=\"adf-tag-list-controls\">\n    <button\n        *ngIf=\"!isSizeMinimum\"\n        [disabled]=\"isLoading\"\n        data-automation-id=\"show-fewer-tags\"\n        mat-icon-button\n        (click)=\"loadLessTags()\">\n        <mat-icon>keyboard_arrow_up</mat-icon>\n    </button>\n    <button\n        *ngIf=\"pagination.hasMoreItems\"\n        [disabled]=\"isLoading\"\n        data-automation-id=\"show-more-tags\"\n        mat-icon-button\n        (click)=\"loadMoreTags()\">\n        <mat-icon>keyboard_arrow_down</mat-icon>\n    </button>\n</div>\n"]}

package/esm2022/lib/tag/tag-node-list/tag-node-list.component.mjs

@@ -0,0 +1,80 @@
+/*!
+ * @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 { Component, DestroyRef, EventEmitter, inject, Input, Output, ViewEncapsulation } from '@angular/core';
+import { TagService } from '../services/tag.service';
+import { DynamicChipListComponent } from '@alfresco/adf-core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/tag.service";
+/**
+ *
+ * This component, ShowNodeTag a list of the tag on relative a node
+ */
+export class TagNodeListComponent {
+    get tagChips() {
+        return this._tagChips;
+    }
+    constructor(tagService) {
+        this.tagService = tagService;
+        /** Show delete button */
+        this.showDelete = true;
+        /** Should limit number of tags displayed */
+        this.limitTagsDisplayed = false;
+        /** Emitted when a tag is selected. */
+        this.results = new EventEmitter();
+        this._tagChips = [];
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnChanges() {
+        this.refreshTag();
+    }
+    ngOnInit() {
+        this.tagService.refresh.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.refreshTag());
+    }
+    refreshTag() {
+        if (this.nodeId) {
+            this.tagService.getTagsByNodeId(this.nodeId).subscribe((tagPaging) => {
+                this._tagChips = tagPaging.list.entries.map((tag) => ({
+                    id: tag.entry.id,
+                    name: tag.entry.tag
+                }));
+                this.results.emit(tagPaging.list.entries);
+            });
+        }
+    }
+    removeTag(tag) {
+        this.tagService.removeTag(this.nodeId, tag).subscribe(() => {
+            this.refreshTag();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagNodeListComponent, deps: [{ token: i1.TagService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TagNodeListComponent, isStandalone: true, selector: "adf-tag-node-list", inputs: { nodeId: "nodeId", showDelete: "showDelete", limitTagsDisplayed: "limitTagsDisplayed" }, outputs: { results: "results" }, usesOnChanges: true, ngImport: i0, template: "<adf-dynamic-chip-list\n    [chips]=\"tagChips\"\n    [limitChipsDisplayed]=\"limitTagsDisplayed\"\n    [showDelete]=\"showDelete\"\n    (displayNext)=\"refreshTag()\"\n    (removedChip)=\"removeTag($event)\" />\n", dependencies: [{ kind: "component", type: DynamicChipListComponent, selector: "adf-dynamic-chip-list", inputs: ["pagination", "chips", "showDelete", "disableDelete", "limitChipsDisplayed", "roundUpChips"], outputs: ["displayNext", "removedChip"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagNodeListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-tag-node-list', standalone: true, imports: [DynamicChipListComponent], encapsulation: ViewEncapsulation.None, template: "<adf-dynamic-chip-list\n    [chips]=\"tagChips\"\n    [limitChipsDisplayed]=\"limitTagsDisplayed\"\n    [showDelete]=\"showDelete\"\n    (displayNext)=\"refreshTag()\"\n    (removedChip)=\"removeTag($event)\" />\n" }]
+        }], ctorParameters: () => [{ type: i1.TagService }], propDecorators: { nodeId: [{
+                type: Input,
+                args: [{ required: true }]
+            }], showDelete: [{
+                type: Input
+            }], limitTagsDisplayed: [{
+                type: Input
+            }], results: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tag/tag.module.mjs

@@ -0,0 +1,37 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { TagActionsComponent } from './tag-actions/tag-actions.component';
+import { TagListComponent } from './tag-list/tag-list.component';
+import { TagNodeListComponent } from './tag-node-list/tag-node-list.component';
+import { TagsCreatorComponent } from './tags-creator/tags-creator.component';
+import * as i0 from "@angular/core";
+export const CONTENT_TAG_DIRECTIVES = [TagsCreatorComponent, TagActionsComponent, TagListComponent, TagNodeListComponent];
+/** @deprecated use `...CONTENT_TAG_DIRECTIVES` instead or import standalone components directly */
+export class TagModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TagModule, imports: [TagsCreatorComponent, TagActionsComponent, TagListComponent, TagNodeListComponent], exports: [TagsCreatorComponent, TagActionsComponent, TagListComponent, TagNodeListComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagModule, imports: [CONTENT_TAG_DIRECTIVES] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...CONTENT_TAG_DIRECTIVES],
+                    exports: [...CONTENT_TAG_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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